coherence/lang/lang_spec.hpp

/*
* lang_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_LANG_SPEC_HPP
#define COH_LANG_SPEC_HPP

#include "coherence/lang/compatibility.hpp"

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

COH_OPEN_NAMESPACE2(coherence,lang)

class Object;

/**
* @internal
*
* Definition of terminal class identifier.
*/
template<class T = void> class COH_EXPORT_SPEC Void
    {
    };

/**
* @internal
*
* Definition of class alias, used in Exceptions.
*/
template<class T> class Alias
    {
    public:
        typedef typename T::alias alias;
    };

/**
* @internal
*
* Terminal Alias.
*/
template<> class Alias<Void<> >
    {
    public:
        typedef Void<> alias;
    };

/**
* @internal
*
* Object Alias.
*/
template<> class Alias<Object>
    {
    public:
        typedef Void<Object> alias;
    };


/**
* @internal
*
* Definition of individual link in chain of implemented interfaces.
*
* @see implements
*
* @author mf 2008.07.14
*/
template<class I, class NEXT> class COH_EXPORT_SPEC interface_link
    : public virtual I, public virtual NEXT
    {
    };

/**
* @internal
*
* Terminal interface_link
*/
template<class IGNORE> class COH_EXPORT_SPEC interface_link<void, IGNORE>
    {
    };


/**
* The implements template specifies a list of interfaces which a class or
* interface specification derives from.  Each interface will be virtually
* inheirted by specified class or interface. Up to sixteen interfaces are
* supported, in the case where more are required, they can be specified using
* an interface_link<I> chain.  i.e.
*
* @code
* implements<I1, ..., I15, interface_link<I16, interface_link<I17> > >
* @endcode
*
* @see abstract_spec
* @see class_spec
* @see cloneable_spec
* @see throwable_spec
* @see interface_spec
*
* @author mf 2008.07.14
*/
template<class I1  = void,
         class I2  = void,
         class I3  = void,
         class I4  = void,
         class I5  = void,
         class I6  = void,
         class I7  = void,
         class I8  = void,
         class I9  = void,
         class I10 = void,
         class I11 = void,
         class I12 = void,
         class I13 = void,
         class I14 = void,
         class I15 = void,
         class I16 = void>
class COH_EXPORT_SPEC implements
    {
    public:
        typedef interface_link<I1,
                interface_link<I2,
                interface_link<I3,
                interface_link<I4,
                interface_link<I5,
                interface_link<I6,
                interface_link<I7,
                interface_link<I8,
                interface_link<I9,
                interface_link<I10,
                interface_link<I11,
                interface_link<I12,
                interface_link<I13,
                interface_link<I14,
                interface_link<I15,
                interface_link<I16,
                void > > > > > > > > > > > > > > > >
        implements_chain;
    };

/**
* The extends template indicates the parent class in a class specification.
*
* @see abstract_spec
* @see class_spec
* @see cloneable_spec
* @see throwable_spec
*
* @author mf 2008.07.14
*/
template<class P = Void<>, class A = typename Alias<P>::alias >
class COH_EXPORT_SPEC extends
    {
    public:
        /**
        * Marker for the actual inherited parent class.
        */
        typedef P inherited;

        /**
        * The purpose of this definition is to cause a compilation error if
        * an attempt is made to instantiate the extends template by supplying
        * an interface.
        */
        typedef typename P::super grand;

        /**
        * Alias type used in throwables.
        */
        typedef A alias;
    };

/**
* @internal
*
* Terminal definition in extension hierarchy.
*/
template<> class COH_EXPORT_SPEC extends<Void<>, Void<> >
    {
    public:
        typedef Void<> inherited;
        typedef Void<> alias;
    };

// ----- helper macros used in the creation of specs ------------------------

/**
* The COH_LIST macros create a coma seperated list of names, which each name
* is the same except for a numeric suffix.
*/
#define COH_LIST1(A)                 A##1
#define COH_LIST2(A)  COH_LIST1 (A), A##2
#define COH_LIST3(A)  COH_LIST2 (A), A##3
#define COH_LIST4(A)  COH_LIST3 (A), A##4
#define COH_LIST5(A)  COH_LIST4 (A), A##5
#define COH_LIST6(A)  COH_LIST5 (A), A##6
#define COH_LIST7(A)  COH_LIST6 (A), A##7
#define COH_LIST8(A)  COH_LIST7 (A), A##8
#define COH_LIST9(A)  COH_LIST8 (A), A##9
#define COH_LIST10(A) COH_LIST9 (A), A##10
#define COH_LIST11(A) COH_LIST10(A), A##11
#define COH_LIST12(A) COH_LIST11(A), A##12
#define COH_LIST13(A) COH_LIST12(A), A##13
#define COH_LIST14(A) COH_LIST13(A), A##14
#define COH_LIST15(A) COH_LIST14(A), A##15
#define COH_LIST16(A) COH_LIST15(A), A##16

/**
* The COH_ARG_LIST macros create a comma seperated list of argument
* declarationsnames, which each argument name is the same except for a numeric
* suffix.
*/
#define COH_ARG_LIST1(A)                     const A##1&  a1
#define COH_ARG_LIST2(A)  COH_ARG_LIST1 (A), const A##2&  a2
#define COH_ARG_LIST3(A)  COH_ARG_LIST2 (A), const A##3&  a3
#define COH_ARG_LIST4(A)  COH_ARG_LIST3 (A), const A##4&  a4
#define COH_ARG_LIST5(A)  COH_ARG_LIST4 (A), const A##5&  a5
#define COH_ARG_LIST6(A)  COH_ARG_LIST5 (A), const A##6&  a6
#define COH_ARG_LIST7(A)  COH_ARG_LIST6 (A), const A##7&  a7
#define COH_ARG_LIST8(A)  COH_ARG_LIST7 (A), const A##8&  a8
#define COH_ARG_LIST9(A)  COH_ARG_LIST8 (A), const A##9&  a9
#define COH_ARG_LIST10(A) COH_ARG_LIST9 (A), const A##10& a10
#define COH_ARG_LIST11(A) COH_ARG_LIST10(A), const A##11& a11
#define COH_ARG_LIST12(A) COH_ARG_LIST11(A), const A##12& a12
#define COH_ARG_LIST13(A) COH_ARG_LIST12(A), const A##13& a13
#define COH_ARG_LIST14(A) COH_ARG_LIST13(A), const A##14& a14
#define COH_ARG_LIST15(A) COH_ARG_LIST14(A), const A##15& a15
#define COH_ARG_LIST16(A) COH_ARG_LIST15(A), const A##16& a16

/**
* Declare a set of templated copy constructors.
*
* @param CLASS the class of which the constors are declared
*/
#define COH_DECLARE_PROXY_CONSTRUCTORS(CLASS) \
    CLASS(); \
    CLASS(const CLASS&); \
    virtual ~CLASS(); \
    template<COH_LIST1 (class A)> CLASS(COH_ARG_LIST1 (A)); \
    template<COH_LIST2 (class A)> CLASS(COH_ARG_LIST2 (A)); \
    template<COH_LIST3 (class A)> CLASS(COH_ARG_LIST3 (A)); \
    template<COH_LIST4 (class A)> CLASS(COH_ARG_LIST4 (A)); \
    template<COH_LIST5 (class A)> CLASS(COH_ARG_LIST5 (A)); \
    template<COH_LIST6 (class A)> CLASS(COH_ARG_LIST6 (A)); \
    template<COH_LIST7 (class A)> CLASS(COH_ARG_LIST7 (A)); \
    template<COH_LIST8 (class A)> CLASS(COH_ARG_LIST8 (A)); \
    template<COH_LIST9 (class A)> CLASS(COH_ARG_LIST9 (A)); \
    template<COH_LIST10(class A)> CLASS(COH_ARG_LIST10(A)); \
    template<COH_LIST11(class A)> CLASS(COH_ARG_LIST11(A)); \
    template<COH_LIST12(class A)> CLASS(COH_ARG_LIST12(A)); \
    template<COH_LIST13(class A)> CLASS(COH_ARG_LIST13(A)); \
    template<COH_LIST14(class A)> CLASS(COH_ARG_LIST14(A)); \
    template<COH_LIST15(class A)> CLASS(COH_ARG_LIST15(A)); \
    template<COH_LIST16(class A)> CLASS(COH_ARG_LIST16(A))

/**
* Generate the prefix for a template definition, sutiable for passing to
* another macro.
*/
#define COH_TEMPLATE_DECLARE3(T1, T2, T3) \
    template<class T1, class T2, class T3>
#define COH_TEMPLATE_DECLARE4(T1, T2, T3, T4) \
    template<class T1, class T2, class T3, class T4>

/**
* Generate the prefix for a template class external method declaration,
* sutiable for passing to another macro.
*/
#define COH_TEMPLATE_DEFINE3(T1, T2, T3)  <T1, T2, T3>
#define COH_TEMPLATE_DEFINE4(T1, T2, T3, T4)  <T1, T2, T3, T4>

/**
* Define implementations for the constructors declared.
*
* @param DECLARE the class's template prefix
* @param DEFINE  the class's template parameters
* @param CLASS   the class on which to generate the methods
* @param SUPER   the parent class of CLASS
*/
#define COH_DEFINE_PROXY_CONSTRUCTORS(DECLARE, DEFINE, CLASS, SUPER) \
    DECLARE CLASS DEFINE::CLASS() : SUPER() {} \
    DECLARE CLASS DEFINE::CLASS(const CLASS& that) : SUPER(that) {} \
    DECLARE CLASS DEFINE::~CLASS() {} \
    DECLARE template<COH_LIST1(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST1 (A)) : SUPER(COH_LIST1(a)) {} \
    DECLARE template<COH_LIST2(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST2 (A)) : SUPER(COH_LIST2(a)) {} \
    DECLARE template<COH_LIST3(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST3 (A)) : SUPER(COH_LIST3(a)) {} \
    DECLARE template<COH_LIST4(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST4 (A)) : SUPER(COH_LIST4(a)) {} \
    DECLARE template<COH_LIST5(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST5 (A)) : SUPER(COH_LIST5(a)) {} \
    DECLARE template<COH_LIST6(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST6 (A)) : SUPER(COH_LIST6(a)) {} \
    DECLARE template<COH_LIST7(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST7 (A)) : SUPER(COH_LIST7(a)) {} \
    DECLARE template<COH_LIST8(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST8 (A)) : SUPER(COH_LIST8(a)) {} \
    DECLARE template<COH_LIST9(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST9 (A)) : SUPER(COH_LIST9(a)) {} \
    DECLARE template<COH_LIST10(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST10(A)) : SUPER(COH_LIST10(a)) {} \
    DECLARE template<COH_LIST11(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST11(A)) : SUPER(COH_LIST11(a)) {} \
    DECLARE template<COH_LIST12(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST12(A)) : SUPER(COH_LIST12(a)) {} \
    DECLARE template<COH_LIST13(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST13(A)) : SUPER(COH_LIST13(a)) {} \
    DECLARE template<COH_LIST14(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST14(A)) : SUPER(COH_LIST14(a)) {} \
    DECLARE template<COH_LIST15(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST15(A)) : SUPER(COH_LIST15(a)) {} \
    DECLARE template<COH_LIST16(class A)> \
        CLASS DEFINE::CLASS(COH_ARG_LIST16(A)) : SUPER(COH_LIST16(a)) {}

/**
* Declare and define factory "create" methods.
*
* @param RETURN    the return type from the factory
* @param FUNCTION  the function to be called to produce the the RETURN
*/
#define COH_DEFINE_CREATE_METHODS(RETURN, FUNCTION) \
    static RETURN create() \
        {return FUNCTION();} \
    template<COH_LIST1 (class A)> static RETURN create(COH_ARG_LIST1(A)) \
        {return FUNCTION(COH_LIST1(a));} \
    template<COH_LIST2 (class A)> static RETURN create(COH_ARG_LIST2(A)) \
        {return FUNCTION(COH_LIST2(a));} \
    template<COH_LIST3 (class A)> static RETURN create(COH_ARG_LIST3(A)) \
        {return FUNCTION(COH_LIST3(a));} \
    template<COH_LIST4 (class A)> static RETURN create(COH_ARG_LIST4(A)) \
        {return FUNCTION(COH_LIST4(a));} \
    template<COH_LIST5 (class A)> static RETURN create(COH_ARG_LIST5(A)) \
        {return FUNCTION(COH_LIST5(a));} \
    template<COH_LIST6 (class A)> static RETURN create(COH_ARG_LIST6(A)) \
        {return FUNCTION(COH_LIST6(a));} \
    template<COH_LIST7 (class A)> static RETURN create(COH_ARG_LIST7(A)) \
        {return FUNCTION(COH_LIST7(a));} \
    template<COH_LIST8 (class A)> static RETURN create(COH_ARG_LIST8(A)) \
        {return FUNCTION(COH_LIST8(a));} \
    template<COH_LIST9 (class A)> static RETURN create(COH_ARG_LIST9(A)) \
        {return FUNCTION(COH_LIST9(a));} \
    template<COH_LIST10(class A)> static RETURN create(COH_ARG_LIST10(A)) \
        {return FUNCTION(COH_LIST10(a));} \
    template<COH_LIST11(class A)> static RETURN create(COH_ARG_LIST11(A)) \
        {return FUNCTION(COH_LIST11(a));} \
    template<COH_LIST12(class A)> static RETURN create(COH_ARG_LIST12(A)) \
        {return FUNCTION(COH_LIST12(a));} \
    template<COH_LIST13(class A)> static RETURN create(COH_ARG_LIST13(A)) \
        {return FUNCTION(COH_LIST13(a));} \
    template<COH_LIST14(class A)> static RETURN create(COH_ARG_LIST14(A)) \
        {return FUNCTION(COH_LIST14(a));} \
    template<COH_LIST15(class A)> static RETURN create(COH_ARG_LIST15(A)) \
        {return FUNCTION(COH_LIST15(a));} \
    template<COH_LIST16(class A)> static RETURN create(COH_ARG_LIST16(A)) \
        {return FUNCTION(COH_LIST16(a));}


/**
* The factory class auto-generates static create methods for a class,
* corresponding to the class's constructors.  The factory must be made a
* friend of the defined class so that it may access the protected constructors.
*
* The factory is used by class specifications to provide the class with static
* create methods.  i.e. the result of using a class_spec when defining class
* Foo will result in Foo having auto-generated static create methods.  Direct
* use of the factory for class instantation is not supported.
*
* The factory supports constructors from zero to sixteen parameters. To help
* the template system it is best (though not required) that there are not
* multiple constructors with the same number of parameters. Classes wishing to
* provide custom create methods may simply define them in their class, and
* these will override and hide the factory auto-generated versions.
*
* @see class_spec
* @see cloneable_spec
* @see throwable_spec
*
* @author mf 2008.07.14
*/
template<class T> class COH_EXPORT_SPEC factory
    {
    template<class, class, class> friend class class_spec;

    protected:
        /**
        * 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(T*, new T)
    };

COH_CLOSE_NAMESPACE2

#endif // COH_LANG_SPEC_HPP

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