Oracle Coherence for C++ API
Release 3.6.1.0
E18813-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/lang/lang_spec.hpp

    00001 /*
    00002 * lang_spec.hpp
    00003 *
    00004 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    00005 *
    00006 * Oracle is a registered trademarks of Oracle Corporation and/or its
    00007 * affiliates.
    00008 *
    00009 * This software is the confidential and proprietary information of Oracle
    00010 * Corporation. You shall not disclose such confidential and proprietary
    00011 * information and shall use it only in accordance with the terms of the
    00012 * license agreement you entered into with Oracle.
    00013 *
    00014 * This notice may not be removed or altered.
    00015 */
    00016 #ifndef COH_LANG_SPEC_HPP
    00017 #define COH_LANG_SPEC_HPP
    00018
    00019 #include "coherence/lang/compatibility.hpp"
    00020
    00021 #include "coherence/lang/TypedHandle.hpp"
    00022 #include "coherence/lang/TypedHolder.hpp"
    00023
    00024 COH_OPEN_NAMESPACE2(coherence,lang)
    00025
    00026 class Object;
    00027
    00028 /**
    00029 * @internal
    00030 *
    00031 * Definition of terminal class identifier.
    00032 */
    00033 template<class T = void> class COH_EXPORT_SPEC Void
    00034     {
    00035     protected:
    00036         virtual ~Void()
    00037             {}
    00038
    00039     public:
    00040         /**
    00041         * @internal
    00042         *
    00043         * Perform an optimistic cast from this type to the specified
    00044         * type.  This method is for use by the cast<T> operator.
    00045         *
    00046         * As this is an optimistic test it may produce false negatives, but
    00047         * not false positives.  A negative result should be followed up with a
    00048         * dynamic_cast.
    00049         *
    00050         * @param pInfo  the type to cast to
    00051         *
    00052         * @return NULL on failure, else the cast'd value represented as a
    00053         *         void* which is suitable for direct casting to the
    00054         *         corresponding type.
    00055         */
    00056         virtual void* _cast(const std::type_info* /*pInfo*/) const
    00057             {
    00058             return NULL;
    00059             }
    00060     };
    00061
    00062 /**
    00063 * @internal
    00064 *
    00065 * Definition of class alias, used in Exceptions.
    00066 */
    00067 template<class T> class Alias
    00068     {
    00069     public:
    00070         typedef typename T::alias alias;
    00071     };
    00072
    00073 /**
    00074 * @internal
    00075 *
    00076 * Terminal Alias.
    00077 */
    00078 template<> class Alias<Void<> >
    00079     {
    00080     public:
    00081         typedef Void<> alias;
    00082     };
    00083
    00084 /**
    00085 * @internal
    00086 *
    00087 * Object Alias.
    00088 */
    00089 template<> class Alias<Object>
    00090     {
    00091     public:
    00092         typedef Void<Object> alias;
    00093     };
    00094
    00095
    00096 /**
    00097 * @internal
    00098 *
    00099 * Definition of individual link in chain of implemented interfaces.
    00100 *
    00101 * @see implements
    00102 *
    00103 * @author mf 2008.07.14
    00104 */
    00105 template<class I, class NEXT> class COH_EXPORT_SPEC interface_link
    00106     : public virtual I, public virtual NEXT
    00107     {
    00108     public:
    00109         /**
    00110         * @internal
    00111         *
    00112         * Perform an optimistic cast from this type to the specified
    00113         * type.  Unlike the virtual _cast which is part of class_specs,
    00114         * _icast handles interfaces, and is called only by _cast and thus
    00115         * doesn't need to be virtual.
    00116         *
    00117         * As this is an optimistic test it may produce false negatives, but
    00118         * not false positives.  A negative result should be followed up with a
    00119         * dynamic_cast.
    00120         *
    00121         * @param pInfo  the type to cast to
    00122         *
    00123         * @return NULL on failure, else the cast'd value represented as a
    00124         *         void* which is suitable for direct casting to the
    00125         *         corresponding type.
    00126         */
    00127         void* _icast(const std::type_info* pInfo) const
    00128             {
    00129             // Perform an optimistic cast, walking across the interface links
    00130             // comparing type_infos by address. This is a shallow traversal
    00131             // avoiding nested interfaces.
    00132             static const std::type_info* pInfoThis = &typeid(I);
    00133             return pInfoThis == pInfo
    00134                 ? (void*) static_cast<const I*>(this)
    00135                 : NEXT::_icast(pInfo);
    00136             }
    00137     };
    00138
    00139 /**
    00140 * @internal
    00141 *
    00142 * Terminal interface_link
    00143 */
    00144 template<class IGNORE> class COH_EXPORT_SPEC interface_link<void, IGNORE>
    00145     {
    00146     public:
    00147     void* _icast(const std::type_info* /*pInfo*/) const
    00148         {
    00149         return NULL;
    00150         }
    00151     };
    00152
    00153
    00154 /**
    00155 * The implements template specifies a list of interfaces which a class or
    00156 * interface specification derives from.  Each interface will be virtually
    00157 * inherited by specified class or interface. Up to sixteen interfaces are
    00158 * supported, in the case where more are required, they can be specified using
    00159 * an interface_link<I> chain.  i.e.
    00160 *
    00161 * @code
    00162 * implements<I1, ..., I15, interface_link<I16, interface_link<I17> > >
    00163 * @endcode
    00164 *
    00165 * @see abstract_spec
    00166 * @see class_spec
    00167 * @see cloneable_spec
    00168 * @see throwable_spec
    00169 * @see interface_spec
    00170 *
    00171 * @author mf 2008.07.14
    00172 */
    00173 template<class I1  = void,
    00174          class I2  = void,
    00175          class I3  = void,
    00176          class I4  = void,
    00177          class I5  = void,
    00178          class I6  = void,
    00179          class I7  = void,
    00180          class I8  = void,
    00181          class I9  = void,
    00182          class I10 = void,
    00183          class I11 = void,
    00184          class I12 = void,
    00185          class I13 = void,
    00186          class I14 = void,
    00187          class I15 = void,
    00188          class I16 = void>
    00189 class COH_EXPORT_SPEC implements
    00190     {
    00191     public:
    00192         typedef interface_link<I1,
    00193                 interface_link<I2,
    00194                 interface_link<I3,
    00195                 interface_link<I4,
    00196                 interface_link<I5,
    00197                 interface_link<I6,
    00198                 interface_link<I7,
    00199                 interface_link<I8,
    00200                 interface_link<I9,
    00201                 interface_link<I10,
    00202                 interface_link<I11,
    00203                 interface_link<I12,
    00204                 interface_link<I13,
    00205                 interface_link<I14,
    00206                 interface_link<I15,
    00207                 interface_link<I16,
    00208                 void > > > > > > > > > > > > > > > >
    00209         implements_chain;
    00210     };
    00211
    00212 /**
    00213 * The extends template indicates the parent class in a class specification.
    00214 *
    00215 * @see abstract_spec
    00216 * @see class_spec
    00217 * @see cloneable_spec
    00218 * @see throwable_spec
    00219 *
    00220 * @author mf 2008.07.14
    00221 */
    00222 template<class P = Void<>, class A = typename Alias<P>::alias >
    00223 class COH_EXPORT_SPEC extends
    00224     {
    00225     public:
    00226         /**
    00227         * Marker for the actual inherited parent class.
    00228         */
    00229         typedef P inherited;
    00230
    00231         /**
    00232         * The purpose of this definition is to cause a compilation error if
    00233         * an attempt is made to instantiate the extends template by supplying
    00234         * an interface.
    00235         */
    00236         typedef typename P::super grand;
    00237
    00238         /**
    00239         * Alias type used in throwables.
    00240         */
    00241         typedef A alias;
    00242     };
    00243
    00244 /**
    00245 * @internal
    00246 *
    00247 * Terminal definition in extension hierarchy.
    00248 */
    00249 template<> class COH_EXPORT_SPEC extends<Void<>, Void<> >
    00250     {
    00251     public:
    00252         typedef Void<> inherited;
    00253         typedef Void<> alias;
    00254     };
    00255
    00256 // ----- helper macros used in the creation of specs ------------------------
    00257
    00258 /**
    00259 * The COH_LIST macros create a comma separated list of names, which each name
    00260 * is the same except for a numeric suffix.
    00261 */
    00262 #define COH_LIST1(A)                 A##1
    00263 #define COH_LIST2(A)  COH_LIST1 (A), A##2
    00264 #define COH_LIST3(A)  COH_LIST2 (A), A##3
    00265 #define COH_LIST4(A)  COH_LIST3 (A), A##4
    00266 #define COH_LIST5(A)  COH_LIST4 (A), A##5
    00267 #define COH_LIST6(A)  COH_LIST5 (A), A##6
    00268 #define COH_LIST7(A)  COH_LIST6 (A), A##7
    00269 #define COH_LIST8(A)  COH_LIST7 (A), A##8
    00270 #define COH_LIST9(A)  COH_LIST8 (A), A##9
    00271 #define COH_LIST10(A) COH_LIST9 (A), A##10
    00272 #define COH_LIST11(A) COH_LIST10(A), A##11
    00273 #define COH_LIST12(A) COH_LIST11(A), A##12
    00274 #define COH_LIST13(A) COH_LIST12(A), A##13
    00275 #define COH_LIST14(A) COH_LIST13(A), A##14
    00276 #define COH_LIST15(A) COH_LIST14(A), A##15
    00277 #define COH_LIST16(A) COH_LIST15(A), A##16
    00278
    00279 /**
    00280 * The COH_ARG_LIST macros create a comma separated list of argument
    00281 * declarations names, which each argument name is the same except for a
    00282 * numeric suffix.
    00283 */
    00284 #define COH_ARG_LIST1(A)                     A##1&  a1
    00285 #define COH_ARG_LIST2(A)  COH_ARG_LIST1 (A), A##2&  a2
    00286 #define COH_ARG_LIST3(A)  COH_ARG_LIST2 (A), A##3&  a3
    00287 #define COH_ARG_LIST4(A)  COH_ARG_LIST3 (A), A##4&  a4
    00288 #define COH_ARG_LIST5(A)  COH_ARG_LIST4 (A), A##5&  a5
    00289 #define COH_ARG_LIST6(A)  COH_ARG_LIST5 (A), A##6&  a6
    00290 #define COH_ARG_LIST7(A)  COH_ARG_LIST6 (A), A##7&  a7
    00291 #define COH_ARG_LIST8(A)  COH_ARG_LIST7 (A), A##8&  a8
    00292 #define COH_ARG_LIST9(A)  COH_ARG_LIST8 (A), A##9&  a9
    00293 #define COH_ARG_LIST10(A) COH_ARG_LIST9 (A), A##10& a10
    00294 #define COH_ARG_LIST11(A) COH_ARG_LIST10(A), A##11& a11
    00295 #define COH_ARG_LIST12(A) COH_ARG_LIST11(A), A##12& a12
    00296 #define COH_ARG_LIST13(A) COH_ARG_LIST12(A), A##13& a13
    00297 #define COH_ARG_LIST14(A) COH_ARG_LIST13(A), A##14& a14
    00298 #define COH_ARG_LIST15(A) COH_ARG_LIST14(A), A##15& a15
    00299 #define COH_ARG_LIST16(A) COH_ARG_LIST15(A), A##16& a16
    00300
    00301 /**
    00302 * Define a proxy constructor with N arguments.
    00303 */
    00304 #define COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, N) \
    00305     template<COH_LIST##N (class A)> SPEC(COH_ARG_LIST##N (A)) \
    00306         : super_spec(COH_LIST##N (a)) {} \
    00307     template<COH_LIST##N (class A)> SPEC(COH_ARG_LIST##N (const A)) \
    00308         : super_spec(COH_LIST##N (a)) {}
    00309
    00310 /**
    00311 * Define a set of templated copy constructors.
    00312 *
    00313 * @param SPEC the class of which the constructors are declared
    00314 */
    00315 #define COH_DEFINE_PROXY_CONSTRUCTORS(SPEC) \
    00316     SPEC() : super_spec() {} \
    00317     SPEC(const SPEC& that) : super_spec(that) {} \
    00318     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 1)  \
    00319     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 2)  \
    00320     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 3)  \
    00321     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 4)  \
    00322     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 5)  \
    00323     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 6)  \
    00324     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 7)  \
    00325     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 8)  \
    00326     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 9)  \
    00327     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 10) \
    00328     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 11) \
    00329     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 12) \
    00330     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 13) \
    00331     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 14) \
    00332     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 15) \
    00333     COH_DEFINE_PROXY_CONSTRUCTOR(SPEC, 16)
    00334
    00335 /**
    00336 * Define a factory create method with N arguments.
    00337 */
    00338 #define COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, N) \
    00339     template<COH_LIST##N (class A)> static RETURN create(COH_ARG_LIST##N (A)) \
    00340         {return FUNCTION(COH_LIST##N(a));} \
    00341     template<COH_LIST##N (class A)> static RETURN create(COH_ARG_LIST##N (const A)) \
    00342         {return FUNCTION(COH_LIST##N(a));}
    00343
    00344 /**
    00345 * Define factory "create" methods.
    00346 *
    00347 * @param RETURN    the return type from the factory
    00348 * @param FUNCTION  the function to be called to produce the the RETURN
    00349 */
    00350 #define COH_DEFINE_CREATE_METHODS(RETURN, FUNCTION) \
    00351     static RETURN create() {return FUNCTION();}  \
    00352     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 1)  \
    00353     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 2)  \
    00354     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 3)  \
    00355     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 4)  \
    00356     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 5)  \
    00357     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 6)  \
    00358     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 7)  \
    00359     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 8)  \
    00360     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 9)  \
    00361     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 10) \
    00362     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 11) \
    00363     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 12) \
    00364     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 13) \
    00365     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 14) \
    00366     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 15) \
    00367     COH_DEFINE_PROXY_CREATE_METHOD(RETURN, FUNCTION, 16)
    00368
    00369 /**
    00370 * The factory class auto-generates static create methods for a class,
    00371 * corresponding to the class's constructors.  The factory must be made a
    00372 * friend of the defined class so that it may access the protected constructors.
    00373 *
    00374 * The factory is used by class specifications to provide the class with static
    00375 * create methods.  i.e. the result of using a class_spec when defining class
    00376 * Foo will result in Foo having auto-generated static create methods.  Direct
    00377 * use of the factory for class instantiation is not supported.
    00378 *
    00379 * The factory supports constructors from zero to sixteen parameters. To help
    00380 * the template system it is best (though not required) that there are not
    00381 * multiple constructors with the same number of parameters. Classes wishing to
    00382 * provide custom create methods may simply define them in their class, and
    00383 * these will override and hide the factory auto-generated versions.
    00384 *
    00385 * @see class_spec
    00386 * @see cloneable_spec
    00387 * @see throwable_spec
    00388 *
    00389 * @author mf 2008.07.14
    00390 */
    00391 template<class T> class COH_EXPORT_SPEC factory
    00392     {
    00393     template<class, class, class> friend class class_spec;
    00394
    00395     protected:
    00396         /**
    00397         * Generate a set of static "create" methods matching the signatures of
    00398         * class T's constructors.
    00399         *
    00400         * NOTE: Compilation errors referencing this line likely indicate that
    00401         *       the parameters supplied by the caller to the create method did
    00402         *       not match one of the constructors.
    00403         */
    00404         COH_DEFINE_CREATE_METHODS(T*, new T)
    00405     };
    00406
    00407 COH_CLOSE_NAMESPACE2
    00408
    00409 #endif // COH_LANG_SPEC_HPP

Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.