coherence/lang/class_spec.hpp

/*
* class_spec.hpp
*
* Copyright 2001-2008 by Oracle. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_CLASS_SPEC_HPP
#define COH_CLASS_SPEC_HPP

#include "coherence/lang/compatibility.hpp"

#include "coherence/lang/lang_spec.hpp"
#include "coherence/lang/TypedHandle.hpp"
#include "coherence/lang/TypedHolder.hpp"

COH_OPEN_NAMESPACE2(coherence,lang)

class Object;

extern COH_EXPORT void coh_throw_clone_not_supported(const std::type_info&);


/**
* Helper for defining a non-cloneable concrete managed class.
*
* Managed classes are implementations of coherence::lang::Object, and include
* a set of well known features, which are auto-generated by this helper class:
*
* - Handle/View/Holder defintions
* - super class definition
* - virtual interface inheritance of up to 16 interfaces
* - public static create methods which delegate to protected constructors with
*   up to sixteen arguments
* - automatic sizeOf() defintion
*
* The template takes three parameters:
*
* - The name of the class being defined
* - The defined classes parent class, indicated as extends<parent>
* - An optional list of interfaces to implement, indicated as
*   implements<i1, i2, ...>
*
* A normal class defintion would be:
* @code
* class Foo
*   : public class_spec<Foo,
*       extends<Bar>,
*       implements<SomeInterface, SomeOtherInterface> >
*   {
*   // add support for auto-generated static create methods
*   friend class factory<Foo>;
*
*   protected:
*       // Constructors are defined as protected, and access via
*       // auto-generated create methods, with matching signatures
*       Foo()
*           : super() // calls Bar()
*           {
*           }
*
*   public:
*       // normal class definition....
*   };
* @endcode
*
* @see extends
* @see implements
*
* @author mf 2008.07.14
*/
template<class T, class E = extends<Object, void>, class I = implements<> >
class COH_EXPORT_SPEC class_spec
    : public E, public E::inherited, public virtual I::implements_chain
    {
    // ----- typedefs -------------------------------------------------------

    public:
        /**
        * Specification definition
        */
        typedef class_spec this_spec;

        /**
        * Factory for this class
        */
        typedef factory<T> factory_spec;

        /**
        * Definition T's actual parent class
        */
        typedef class_spec super;

        /**
        * Definition T's logical parent class
        */
        typedef typename E::inherited inherited;

        /**
        * @internal
        *
        * Definition T's alias
        */
        typedef typename E::alias alias;

        /**
        * Standard Handle definition
        */
        typedef TypedHandle<T> Handle;

        /**
        * Standard View definition
        */
        typedef TypedHandle<const T> View;

        /**
        * Standard Holder defintion
        */
        typedef TypedHolder<T> Holder;


    // ----- constructors ---------------------------------------------------

    protected:
        /**
        * Generate a set of proxy constuctors matching the signatures of the
        * parent class's constructors.
        *
        * NOTE: Compilation errors referencing this line likely indicate that
        *       class being defined by this spec makes calls a "super"
        *       constructor supplying a set of parameters for which there is
        *       no exact match on the parent class.
        */
        COH_DECLARE_PROXY_CONSTRUCTORS(class_spec);

    public:
        /**
        * Generate a set of static "create" methods matching the signatures of
        * class T's constructors.
        *
        * NOTE: Compilation errors referencing this line likely indicate that
        *       the parameters supplied by the caller to the create method did
        *       not match one of the constructors.
        */
        COH_DEFINE_CREATE_METHODS(Handle, factory_spec::create)

        virtual TypedHandle<Object> clone() const
            {
            coh_throw_clone_not_supported(typeid(T));
            return NULL;
            }

        virtual size32_t sizeOf() const
            {
            return sizeof(T);
            }

    protected:
        /**
        * @internal
        *
        * Protect access to create method generated for the copy constructor.
        */
        static inline Handle create(const T& that)
            {
            return factory_spec::create(that);
            }
    };
COH_DEFINE_PROXY_CONSTRUCTORS(COH_TEMPLATE_DECLARE3(T, E, I), \
        COH_TEMPLATE_DEFINE3(T, E, I), class_spec, inherited)

COH_CLOSE_NAMESPACE2

#endif // COH_CLASS_SPEC_HPP

Copyright (c) 2000-2008 Oracle. All rights reserved.