C++ Client API Reference for Oracle Coherence
14c (14.1.2.0.0)
F79659-03

coherence/lang/compatibility.hpp

00001 /*
00002  * Copyright (c) 2000, 2025, Oracle and/or its affiliates.
00003  *
00004  * Licensed under the Universal Permissive License v 1.0 as shown at
00005  * https://oss.oracle.com/licenses/upl.
00006  */
00007 #ifndef COH_COMPATIBILITY_HPP
00008 #define COH_COMPATIBILITY_HPP
00009 
00010 /// @cond EXCLUDE
00011 
00012 #include <typeinfo>
00013 
00014 // ----- identify operating system ------------------------------------------
00015 
00016 #if defined(_WIN32)
00017 #   define COH_OS_WINDOWS
00018 #   define COH_LIB_PREFIX ""
00019 #   define COH_LIB_SUFFIX ".dll"
00020 #   if defined(_WIN64)
00021 #      define COH_OS_WIN64
00022 #      define COH_PLATFORM Microsoft Windows x64
00023 #   else
00024 #      define COH_OS_WIN32
00025 #      define COH_PLATFORM Microsoft Windows x86
00026 #   endif
00027 #elif defined(__sun) || defined(sun)
00028 #   define COH_OS_SOLARIS // Oracle Solaris
00029 #   define COH_OS_UNIX
00030 #   define COH_LIB_PREFIX "lib"
00031 #   define COH_LIB_SUFFIX ".so"
00032 #   include <sys/types.h> // for _LP64 definition
00033 #   if defined(__sparc)
00034 #       if defined(_LP64)
00035 #           define COH_OS_SOLARIS64
00036 #           define COH_PLATFORM Oracle Solaris SPARC 64b
00037 #       else
00038 #           define COH_OS_SOLARIS32
00039 #           define COH_PLATFORM Oracle Solaris SPARC 32b
00040 #       endif
00041 #   elif defined(__x86)
00042 #       if defined(_LP64)
00043 #           define COH_OS_SOLARIS64
00044 #           define COH_PLATFORM Oracle Solaris x64
00045 #       else
00046 #           define COH_OS_SOLARIS32
00047 #           define COH_PLATFORM Oracle Solaris x86
00048 #       endif
00049 #   endif
00050 #elif defined(__linux__)
00051 #   define COH_OS_LINUX // Linux
00052 #   define COH_LIB_PREFIX "lib"
00053 #   define COH_LIB_SUFFIX ".so"
00054 #   define COH_OS_UNIX
00055 #   if defined(__x86_64__) || defined(__amd64__)
00056 #       define COH_OS_LINUX64
00057 #       define COH_PLATFORM Linux x64
00058 #   elif defined(__x86_32__) || defined(__i386__)
00059 #       define COH_OS_LINUX32
00060 #       define COH_PLATFORM Linux x86
00061 #   elif defined (__aarch64__)
00062 #       define COH_OS_LINUXAARCH64
00063 #       define COH_PLATFORM Linux aarch64
00064 #   endif
00065 #elif defined(__APPLE__)
00066 #   define COH_OS_DARWIN // OS X
00067 #   define COH_OS_UNIX
00068 #   define COH_LIB_PREFIX "lib"
00069 #   define COH_LIB_SUFFIX ".dylib"
00070 #   if defined(__x86_64__) || defined(__amd64__)
00071 #       define COH_OS_DARWIN64
00072 #       define COH_PLATFORM Apple macOS x64
00073 #   elif defined (__aarch64__)
00074 #       define COH_OS_DARWINAARCH64
00075 #       define COH_PLATFORM Apple macOS arm64
00076 #   endif
00077 #endif
00078 
00079 #ifndef COH_PLATFORM
00080 #   error "Coherence for C++ does not support this platform."
00081 #endif
00082 
00083 
00084 // ----- identify compiler --------------------------------------------------
00085 
00086 #if defined(_MSC_VER) && _MSC_VER >= 1600
00087 #   define COH_CC_MSVC // Microsoft Visual C/C++
00088 #   define COH_CC MSVC
00089 #elif defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x590
00090 #   define COH_CC_SUN // Oracle Solaris Studio
00091 #   if defined (STLPORT)
00092 #       define COH_CC SunPro STLport
00093 #   else
00094 #       define COH_CC SunPro
00095 #   endif
00096 #elif defined(__GNUG__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00097 #   define COH_CC_GNU // GNU C++
00098 #   if defined (__clang__)
00099 #       define COH_CC LLVM (clang)
00100 #   else
00101 #       define COH_CC GCC
00102 #   endif
00103 #else
00104 #   error "Coherence for C++ does not support this compiler or compiler version."
00105 #endif
00106 
00107 
00108 // ----- disable select warnings --------------------------------------------
00109 
00110 /**
00111 * Macro for disabling select warnings on MSVC. The warnings are automatically
00112 * disabled upon opening a coherence namespace (using the COH_OPEN_NAMESPACE
00113 * macros), and re-enabled when the namespace is exited via
00114 * COH_CLOSE_NAMESPACE.
00115 */
00116 #if defined(COH_CC_MSVC)
00117     #define COH_PRAGMA_PUSH \
00118     __pragma(warning(push)) \
00119     /* Allow multiple interface inheritance (inheritance via dominance) */ \
00120     __pragma(warning(disable : 4250)) \
00121     /* Allow non-exported DLL templates */ \
00122     __pragma(warning(disable : 4251)) \
00123     /* Exported class inheritance from non-exported class, needed for specs */ \
00124     __pragma(warning(disable : 4275)) \
00125     /* TypedHandle/Holder: multiple copy constructors */ \
00126     __pragma(warning(disable : 4521)) \
00127     /* Member/WeakHandle: assignment operators for const/non-const type */ \
00128     __pragma(warning(disable : 4522)) \
00129     /* Lack of return statements are being promoted to errors, when control \
00130        path results in throw */ \
00131     __pragma(warning(disable : 4715; disable : 4716))
00132 
00133     #define COH_PRAGMA_POP __pragma(warning(pop))
00134 #else
00135     #define COH_PRAGMA_PUSH
00136     #define COH_PRAGMA_POP
00137 #endif
00138 
00139 /**
00140 * Macro for temporarily disabling above warnings for the duration of a
00141 * single statement.  This is only needed for code which is not enclosed in a
00142 * COH_OPEN/CLOSE_NAMESPACE block.
00143 */
00144 #define COH_NO_WARN(STMT) COH_PRAGMA_PUSH STMT COH_PRAGMA_POP
00145 
00146 /**
00147 * These macros are used to indicate that a function will not return normally.
00148 *
00149 * Usage example:
00150 * @code
00151 * COH_NO_RETURN_PRE void doSomething() COH_NO_RETURN_POST
00152 *     {
00153 *     COH_NO_RETURN_STMT(doSomething2());
00154 *     }
00155 * @endcode
00156 */
00157 #if defined(COH_CC_MSVC)
00158     #define COH_NO_RETURN_PRE __declspec(noreturn)
00159     #define COH_NO_RETURN_POST
00160     #define COH_NO_RETURN_STMT(expr) expr
00161 #elif defined(COH_CC_GNU)
00162     #define COH_NO_RETURN_PRE
00163     #define COH_NO_RETURN_POST __attribute__((noreturn))
00164     #define COH_NO_RETURN_STMT(expr) expr
00165 #elif defined(COH_CC_SUN)
00166     #define COH_NO_RETURN_PRE
00167     #define COH_NO_RETURN_POST
00168     #define COH_NO_RETURN_STMT(expr)\
00169         do { expr; throw std::exception(); } while (0)
00170 #else
00171     #define COH_NO_RETURN_PRE
00172     #define COH_NO_RETURN_POST
00173     #define COH_NO_RETURN_STMT(expr) expr
00174 #endif
00175 
00176 
00177 // ----- namespace macros ---------------------------------------------------
00178 
00179 /**
00180 * Define the existence of the coherence::lang namespace
00181 */
00182 namespace coherence { namespace lang {}}
00183 
00184 #define COH_OPEN_NAMESPACE(ns) namespace ns { \
00185     COH_PRAGMA_PUSH \
00186     using namespace coherence::lang;
00187 
00188 #define COH_INNER_NAMESPACE(ns) namespace ns {
00189 
00190 #define COH_OPEN_NAMESPACE2(ns1, ns2)\
00191     COH_OPEN_NAMESPACE (ns1) COH_INNER_NAMESPACE (ns2)
00192 
00193 #define COH_OPEN_NAMESPACE3(ns1, ns2, ns3)\
00194     COH_OPEN_NAMESPACE2 (ns1, ns2) COH_INNER_NAMESPACE (ns3)
00195 
00196 #define COH_OPEN_NAMESPACE4(ns1, ns2, ns3, ns4)\
00197     COH_OPEN_NAMESPACE3 (ns1, ns2, ns3) COH_INNER_NAMESPACE (ns4)
00198 
00199 #define COH_OPEN_NAMESPACE5(ns1, ns2, ns3, ns4, ns5)\
00200     COH_OPEN_NAMESPACE4 (ns1, ns2, ns3, ns4) COH_INNER_NAMESPACE (ns5)
00201 
00202 #define COH_OPEN_NAMESPACE6(ns1, ns2, ns3, ns4, ns5, ns6)\
00203     COH_OPEN_NAMESPACE5 (ns1, ns2, ns3, ns4, ns5) COH_INNER_NAMESPACE (ns6)
00204 
00205 #define COH_OPEN_NAMESPACE7(ns1, ns2, ns3, ns4, ns5, ns6, ns7)\
00206     COH_OPEN_NAMESPACE6 (ns1, ns2, ns3, ns4, ns5, ns6) COH_INNER_NAMESPACE (ns7)
00207 
00208 #define COH_CLOSE_NAMESPACE COH_PRAGMA_POP }
00209 
00210 #define COH_CLOSE_NAMESPACE2 COH_PRAGMA_POP } }
00211 
00212 #define COH_CLOSE_NAMESPACE3 COH_PRAGMA_POP } } }
00213 
00214 #define COH_CLOSE_NAMESPACE4 COH_PRAGMA_POP } } } }
00215 
00216 #define COH_CLOSE_NAMESPACE5 COH_PRAGMA_POP } } } } }
00217 
00218 #define COH_CLOSE_NAMESPACE6 COH_PRAGMA_POP } } } } } }
00219 
00220 #define COH_CLOSE_NAMESPACE7 COH_PRAGMA_POP } } } } } } }
00221 
00222 /**
00223 * Pseudo-anonymous namespaces.  Starting with Visual Studio 2017 it is no
00224 * longer possible to define Coherence managed classes within an anonymous
00225 * namespace.
00226 *
00227 * The parameter NAME should be unique to the parent namespace. Generally
00228 * this can simply be the name of the primary class being defined within the
00229 * file.
00230 *
00231 * For platforms other than Visual Studio 2017 and later, these macros will
00232 * open and close a standard anonymous namespace.
00233 */
00234 #if defined(COH_CC_MSVC) && _MSC_VER >= 1900
00235     #define COH_OPEN_NAMESPACE_ANON(NAME)\
00236         namespace COH_JOIN(_anon_, NAME) {}\
00237         using namespace COH_JOIN(_anon_, NAME);\
00238         namespace COH_JOIN(_anon_, NAME) {
00239 #else
00240     #define COH_OPEN_NAMESPACE_ANON(NAME) namespace {
00241 #endif
00242 
00243 #define COH_CLOSE_NAMESPACE_ANON }
00244 
00245 // ----- general utility macros ---------------------------------------------
00246 
00247 /**
00248 * This macro "mangles" the specified @a Name, producing an identifier which
00249 * is unique in the current file.
00250 *
00251 * Note. This implementation of COH_UNIQUE_IDENTIFIER (as well as macros that
00252 * use it) won't work in MSVC 6.0 when -ZI is on! See Q199057.
00253 *
00254 * @param Name the name to produce a new identifier on its basis
00255 */
00256 #define COH_JOIN(X, Y) COH_DO_JOIN(X, Y)
00257 #define COH_DO_JOIN(X, Y) COH_DO_JOIN2(X, Y)
00258 #define COH_DO_JOIN2(X, Y) X##Y
00259 #ifdef COH_CC_MSVC_NET // MSVC 2002 and later
00260 #   define COH_UNIQUE_IDENTIFIER(Name) COH_JOIN(Name, __COUNTER__)
00261 #else
00262 #   define COH_UNIQUE_IDENTIFIER(Name) COH_JOIN(Name, __LINE__)
00263 #endif
00264 
00265 /**
00266 * This macro will ensure initialization of function local statics at library
00267 * load time. This should be used to force the initialization of statics
00268 * in a thread safe way.  The general form is:
00269 *
00270 * SomeType::Handle staticAccessorFunction()
00271 *     {
00272 *     static FinalHandle<SomeType> hStatic = SomeType::create();
00273 *     return hStatic;
00274 *     }
00275 * COH_STATIC_INIT(staticAccessorFunction());
00276 *
00277 * @param FUNC  The static function and parameters to call that requires
00278 *             initialization.
00279 */
00280 #ifdef COH_EAGER_INIT
00281 #   define COH_STATIC_INIT_EX(N, FUNC) \
00282     static const bool COH_UNIQUE_IDENTIFIER(coh_static_init_func##N##_) = (FUNC, true)
00283 #else
00284 // some platforms (Windows) have serious restrictions about what can be safely
00285 // performed during static initialization and so this variant of initializer
00286 // records the initializers in the order they would be loaded to allow for
00287 // execution after the library has been loaded. The execution can be triggered
00288 // by running System::loadLibrary(NULL)
00289 #    define COH_STATIC_INIT_EX(N, FUNC) \
00290          static void COH_UNIQUE_IDENTIFIER(coh_static_init_func##N##_)() {FUNC;} \
00291          static coherence::lang::coh_initializer \
00292                  COH_UNIQUE_IDENTIFIER(coh_static_init_reg##N##_) \
00293          (&COH_UNIQUE_IDENTIFIER(coh_static_init_func##N##_))
00294 #endif
00295 
00296 #define COH_STATIC_INIT(FUNC) COH_STATIC_INIT_EX(0, FUNC)
00297 
00298 COH_OPEN_NAMESPACE2(coherence,lang)
00299     template <bool x> struct STATIC_ASSERTION_FAILURE;
00300     template<> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
00301 COH_CLOSE_NAMESPACE2
00302 
00303 /**
00304 * This macro generates a compile time error message if the integral constant
00305 * expression @a B is not true. In other words, it is the compile time
00306 * equivalent of the @c assert macro. Note that if the condition is true, then
00307 * the macro will generate neither code nor data - and the macro can also be
00308 * used at either namespace, class or function scope. When used in a template,
00309 * the static assertion will be evaluated at the time the template is
00310 * instantiated; this is particularly useful for validating template
00311 * parameters.
00312 *
00313 * #COH_STATIC_ASSERT can be used at any place where a declaration can be
00314 * placed, that is at class, function or namespace scope.
00315 *
00316 * @param B an integral constant expression to check its trueness during
00317 *          translation phase
00318 */
00319 #define COH_STATIC_ASSERT(B)                               \
00320     enum { COH_UNIQUE_IDENTIFIER(coh_static_assert_enum_) =\
00321         sizeof(coherence::lang::STATIC_ASSERTION_FAILURE<(bool)(B)>) }
00322 
00323 /**
00324 * DLL import/export macros.
00325 */
00326 #if defined(COH_CC_MSVC)
00327     #ifdef COH_BUILD
00328         #define COH_EXPORT  __declspec(dllexport)
00329     #else
00330         #define COH_EXPORT  __declspec(dllimport)
00331     #endif
00332     #define COH_EXPORT_SPEC  __declspec(dllexport)
00333     #if _MSC_VER >= 1900
00334         #define COH_EXPORT_SPEC_MEMBER(DECL) DECL;
00335     #else
00336         #define COH_EXPORT_SPEC_MEMBER(DECL)
00337     #endif
00338 #else
00339     #define COH_EXPORT
00340     #define COH_EXPORT_SPEC
00341     #define COH_EXPORT_SPEC_MEMBER(DECL) DECL;
00342 #endif
00343 
00344 /**
00345 * This macro will strongly encourage/force inlining of a method.
00346 */
00347 #if defined(COH_CC_MSVC)
00348     #define COH_INLINE __forceinline
00349 #elif defined(COH_CC_GNU)
00350     #define COH_INLINE __attribute__((always_inline)) inline
00351 #else
00352     #define COH_INLINE __attribute__((always_inline)) inline
00353 #endif
00354 
00355 /**
00356 * This macro expands to the name and signature of the current function.
00357 */
00358 #if defined(__GNUC__)
00359     #define COH_CURRENT_FUNCTION __PRETTY_FUNCTION__
00360 #elif defined(__FUNCSIG__)
00361     #define COH_CURRENT_FUNCTION __FUNCSIG__
00362 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
00363     #define COH_CURRENT_FUNCTION __func__
00364 #else
00365     #define COH_CURRENT_FUNCTION "(unknown function)"
00366 #endif
00367 
00368 /**
00369  * This macro controls alignment
00370  */
00371 #if defined(COH_CC_GNU)
00372     #define COH_ALIGN(B, TYPE, NAME) TYPE NAME __attribute__ ((aligned (B)))
00373 #elif defined(COH_CC_SUN)
00374     #define COH_SUNPRO_PRAGMA(S) _Pragma(S)
00375     #define COH_ALIGN(B, TYPE, NAME) COH_SUNPRO_PRAGMA(COH_SYMB_STRING(align B(NAME))) TYPE NAME
00376 #elif defined(COH_CC_MSVC)
00377     #define COH_ALIGN(B, TYPE, NAME) __declspec(align(B)) TYPE NAME
00378 #else
00379     #error "No Coherence alignment macro for this compiler"
00380 #endif
00381 
00382 /**
00383  * Macro to declare whether a function throws exceptions.
00384  */
00385 #if __cplusplus > 199711L ||\
00386     defined(_MSC_VER) && _MSC_VER >= 1900
00387 #       define COH_NOEXCEPT(expr) noexcept(expr)
00388 #else
00389 #       define COH_NOEXCEPT(expr)
00390 #endif
00391 
00392 /**
00393  * Macro to use appropriate C++ language specific smart pointer.
00394  *
00395  * std::auto_ptr is deprecated in C++11 and its use may throw compiler warnings.
00396  */
00397 #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
00398 #   define COH_AUTO_PTR std::unique_ptr
00399 #else
00400 #   define COH_AUTO_PTR std::auto_ptr
00401 #endif
00402 
00403 // ----- fixed size types ---------------------------------------------------
00404 
00405 // We need to include an std lib header here in order to detect which library
00406 // is in use (__GLIBC__ may not be defined without this including). Use
00407 // <utility> as it's about the smallest of the std lib headers.
00408 #include <utility>
00409 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901 ||\
00410     defined(_POSIX_VERSION) && _POSIX_VERSION >= 200100 ||\
00411     defined(COH_OS_LINUX) &&\
00412         defined(__GLIBC__) &&\
00413         (__GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) &&\
00414         defined(__GNUC__) ||\
00415     defined(COH_OS_DARWIN) && __MACH__ && !defined(_MSL_USING_MSL_C)
00416 #       define COH_HAS_STDINT_H
00417 #endif
00418 
00419 #if defined(__GCCXML__) ||\
00420     defined(__GNUC__) ||\
00421     defined(_MSC_EXTENSIONS)
00422 #       define COH_HAS_LONG_LONG
00423 #endif
00424 
00425 #if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) &&\
00426         !defined(_GLIBCPP_USE_LONG_LONG) &&          \
00427         !defined(_GLIBCXX_USE_LONG_LONG) &&          \
00428         defined(COH_HAS_LONG_LONG)
00429     // Coming here indicates that the GNU compiler supports long long type,
00430     // but the GNU C++ runtime library does not. Particularly, no global
00431     // operator<<(std::ostream&, long long) implementation is provided. Let us
00432     // provide it, at least with minimum incomplete functionality.
00433 #   include <ostream>
00434     namespace std
00435         {
00436         template<class E, class T>
00437         inline basic_ostream<E, T>& operator<<
00438                 (basic_ostream<E, T>& out, long long l)
00439             {
00440             return out << static_cast<long>(l);
00441             }
00442         template<class E, class T>
00443         inline basic_ostream<E, T>& operator<<
00444                 (basic_ostream<E, T>& out, unsigned long long l)
00445             {
00446             return out << static_cast<unsigned long>(l);
00447             }
00448         }
00449 #   undef COH_HAS_LONG_LONG
00450 #endif
00451 
00452 #if !defined(COH_HAS_LONG_LONG) && !defined(COH_CC_MSVC)
00453 #   include <limits.h>
00454 #   if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) ||\
00455             defined(ULONGLONG_MAX)
00456 #       define COH_HAS_LONG_LONG
00457 #   endif
00458 #endif
00459 
00460 #if defined(_MSC_VER)
00461 #       define COH_HAS_MS_INT64
00462 #endif
00463 
00464 /**
00465 * Fixed width primitive types.
00466 */
00467 #if defined(COH_HAS_STDINT_H)
00468 #   include <stdint.h>
00469 #elif defined(COH_CC_SUN)
00470 #   include <inttypes.h>
00471 #else
00472 //  This platform does not support the C99 stdint.h types. This code block
00473 //  defines them in the global namespace, alternatively you may define
00474 //  COH_NAMESPACED_FIXED_INTS, in which case these definitions will be within
00475 //  the coherence::lang namespace.
00476 #   include <climits>
00477 #   ifdef COH_NAMESPACED_FIXED_INTS
00478       COH_OPEN_NAMESPACE2(coherence,lang)
00479 #   endif
00480     COH_STATIC_ASSERT(UCHAR_MAX == 0xFF);
00481     typedef signed char   int8_t;
00482     typedef unsigned char uint8_t;
00483     COH_STATIC_ASSERT(USHRT_MAX == 0xFFFF);
00484     typedef short          int16_t;
00485     typedef unsigned short uint16_t;
00486 #   if UINT_MAX == 0xFFFFFFFF
00487         typedef int          int32_t;
00488         typedef unsigned int uint32_t;
00489 #   elif ULONG_MAX == 0xFFFFFFFF
00490         typedef long          int32_t;
00491         typedef unsigned long uint32_t;
00492 #   else
00493 #       error int size not correct
00494 #   endif
00495 #   if defined(COH_HAS_LONG_LONG) &&\
00496         !defined(COH_CC_MSVC) &&\
00497         (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
00498         (defined(ULLONG_MAX) ||\
00499             defined(ULONG_LONG_MAX) ||\
00500             defined(ULONGLONG_MAX))
00501 #               if defined(ULLONG_MAX)
00502                     COH_STATIC_ASSERT(ULLONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
00503 #               elif defined(ULONG_LONG_MAX)
00504                     COH_STATIC_ASSERT
00505                         (ULONG_LONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
00506 #               elif defined(ULONGLONG_MAX)
00507                     COH_STATIC_ASSERT
00508                         (ULONGLONG_MAX == 0xFFFFFFFFFFFFFFFFULL));
00509 #               else
00510 #                   error long long size not correct
00511 #               endif
00512                 typedef long long          int64_t;
00513                 typedef unsigned long long uint64_t;
00514 #   elif ULONG_MAX != 0xFFFFFFFF
00515         COH_STATIC_ASSERT(ULONG_MAX == 0xFFFFFFFFFFFFFFFFULL);
00516         typedef long          int64_t;
00517         typedef unsigned long uint64_t;
00518 #   elif defined(__GNUC__) && defined(COH_HAS_LONG_LONG)
00519         __extension__ typedef long long          int64_t;
00520         __extension__ typedef unsigned long long uint64_t;
00521 #   elif defined(COH_HAS_MS_INT64)
00522         typedef __int64          int64_t;
00523         typedef unsigned __int64 uint64_t;
00524 #   else
00525 #       error no 64-bit integer support
00526 #   endif
00527 #   ifdef COH_NAMESPACED_FIXED_INTS
00528         COH_CLOSE_NAMESPACE2
00529 #   endif
00530 #endif
00531 
00532 /**
00533 * Non-standard primitive type definitions.
00534 */
00535 COH_OPEN_NAMESPACE2(coherence,lang)
00536     typedef unsigned char octet_t;
00537     typedef uint16_t      wchar16_t;
00538     typedef uint32_t      size32_t;
00539     typedef uint64_t      size64_t;
00540     typedef float         float32_t; COH_STATIC_ASSERT(sizeof(float32_t) >= sizeof(int32_t));
00541     typedef double        float64_t; COH_STATIC_ASSERT(sizeof(float64_t) >= sizeof(int64_t));
00542 COH_CLOSE_NAMESPACE2
00543 
00544 /**
00545 * Produce a 64b value from two 32b parts.
00546 *
00547 * This is a bit-wise construction, and the supplied values should be the
00548 * bitwise unsigned representations.  For example:
00549 * COH_INT64(0x7FFFFFFFU, 0xFFFFFFFFU) == 0x7FFFFFFFFFFFFFFFLL
00550 */
00551 #define COH_INT64(HIGH, LOW) int64_t(uint64_t(HIGH) << 32 | uint64_t(LOW))
00552 
00553 // macros for turning compiler supplied define into a string
00554 #define COH_SYMB_STRING(SYMB) #SYMB
00555 #define COH_SYMB_TO_STRING(SYMB) COH_SYMB_STRING(SYMB)
00556 
00557 
00558 // ----- helpers ------------------------------------------------------------
00559 
00560 #include <typeinfo>
00561 COH_OPEN_NAMESPACE2(coherence,lang)
00562     class Class;
00563 
00564     typedef void (*coh_static_initializer)();
00565 
00566     /**
00567     * Register an initialization function with the runtime.
00568     */
00569     extern COH_EXPORT void coh_register_initializer(
00570             coh_static_initializer pInit, bool fAdd);
00571 
00572     /**
00573      * Helper class for registering and unregistering static initializers.
00574      */
00575     class coh_initializer
00576         {
00577         public:
00578 
00579         coh_initializer(coh_static_initializer pInit)
00580             : m_pInit(pInit)
00581             {
00582             coh_register_initializer(pInit, true);
00583             }
00584 
00585         ~coh_initializer()
00586             {
00587             coh_register_initializer(m_pInit, false);
00588             }
00589 
00590         private:
00591         coh_static_initializer m_pInit;
00592         };
00593 
00594     /**
00595     * Helper functions for throwing exceptions.
00596     */
00597     extern COH_EXPORT void coh_throw_npe(const std::type_info&);
00598     extern COH_EXPORT void coh_throw_class_cast(const std::type_info&,
00599             const std::type_info&);
00600     extern COH_EXPORT void coh_throw_const_cast(const std::type_info&,
00601             const std::type_info&);
00602     extern COH_EXPORT void coh_throw_illegal_state(const char* achMsg);
00603     extern COH_EXPORT void coh_throw_illegal_argument(const char* achMsg);
00604     extern COH_EXPORT void coh_throw_unsupported_operation(const char* achMsg);
00605     extern COH_EXPORT const Class* coh_loadClassByType(const std::type_info& ti);
00606 
00607     /**
00608     * Helper class used to test for type assignment compatibility at
00609     * compile time.
00610     *
00611     * This implementation is based on the Conversion example from
00612     * Andrei Alexandrescu's Modern C++ Design.
00613     */
00614     template<class A, class B>
00615     class assignment
00616         {
00617         protected:
00618             typedef char  PathA;
00619             class   Other {char unused[2];}; // sizeof(Other) != sizeof(PathA)
00620             static  PathA route(A*); // PathA taken only for compatible types
00621             static  Other route(...); // incompatible types go this route
00622             static  B*    test(); // "generate" a test object
00623 
00624         public:
00625             /**
00626             * Convert a derived A to an A.
00627             */
00628             static A* safe(A* a)
00629                 {
00630                 return a;
00631                 }
00632 
00633             /**
00634             * Dummy conversion (should never be called)
00635             */
00636             static A* safe(...)
00637                 {
00638                 coh_throw_illegal_state("unsafe cast");
00639                 return 0;
00640                 }
00641 
00642         public:
00643             /**
00644             * True iff A = B is allowed.
00645             */
00646             enum {allowed = (sizeof(route(test())) == sizeof(PathA))};
00647         };
00648 
00649     /**
00650     * Helper class used to test if a type has been declared as const.
00651     */
00652     template<class A>
00653     class constness
00654         {
00655         public:
00656             enum {applied = assignment<A, const A>::allowed};
00657         };
00658 /**
00659  * Coherence Class and Interface ID helpers.
00660  */
00661 #if defined(COH_CC_MSVC)
00662     // MSVC utilizes identical code folding ICF, which makes the alternate
00663     // very cheap form of id generation unusable and effectively assigns
00664     // all classes the same id, thus on MSVC we fallback on standard and
00665     // slower typeid
00666 
00667     /**
00668      * Coherence class id type.
00669      */
00670     typedef const std::type_info& coh_class_id;
00671 
00672     /**
00673      * Return the class id for a given managed class.
00674      */
00675     #define COH_CLASS_ID(CLASS) CLASS::_classId()
00676 
00677     /**
00678      * @internal
00679      *
00680      * Hook for COH_CLASS_ID macro, not for direct use
00681      */
00682     #define COH_GENERATE_CLASS_ID(T) \
00683         static coh_class_id _classId() \
00684             { \
00685             return typeid(T); \
00686             }
00687 #else
00688     // For most compilers we can use the address of a class specific static
00689     // function as a unique class identifier. This is cheaper then using
00690     // the standard typeid operator, which on some platforms adds contention
00691 
00692     /**
00693      * Coherence class id type.
00694      */
00695     typedef void (*coh_class_id)();
00696 
00697     /**
00698      * Return the class id for a given managed class.
00699      */
00700     #define COH_CLASS_ID(CLASS) &CLASS::_classId
00701 
00702     /**
00703      * @internal
00704      *
00705      * Hook for COH_CLASS_ID macro, not for direct use
00706      */
00707     #define COH_GENERATE_CLASS_ID(T) static void _classId() {}
00708 #endif
00709 
00710 COH_CLOSE_NAMESPACE2
00711 
00712 /// @endcond
00713 
00714 #endif // COH_COMPATIBILITY_HPP
Copyright © 2000, 2025, Oracle and/or its affiliates. Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.