/export/leeloo1/users/build/gfcppsancout64/product/include/gfcpp/TypeHelper.hpp

#ifndef _GEMFIRE_TYPEHELPER_HPP_
#define _GEMFIRE_TYPEHELPER_HPP_

/*=========================================================================
 * (c) Copyright 2002-2007, GemStone Systems, Inc. All Rights Reserved.
 * 1260 NW Waterhouse Ave., Suite 200,  Beaverton, OR 97006
 *=========================================================================
 */

#include "gfcpp_globals.hpp"


namespace gemfire
{
  // Forward declaration of SharedPtr<T>
  template<typename Target> class SharedPtr;

  // Forward declaration of SharedArrayPtr<T, ID>
  template<typename Target, int8_t TYPEID> class SharedArrayPtr;

  // Forward declaration of CacheableArrayType<T, ID>
  template<typename Target, int8_t TYPEID> class CacheableArrayType;

  namespace TypeHelper
  {
    typedef uint8_t yes_type;
    typedef uint32_t no_type;

    template <typename TBase, typename TDerived> struct BDHelper
    {
      template <typename T>
        static yes_type check_sig( TDerived const volatile *, T );
      static no_type check_sig( TBase const volatile *, int );
    };

    template <typename TBase, typename TDerived> struct SuperSubclass
    {
      private:

        struct Host
        {
          operator TBase const volatile* ( ) const;
          operator TDerived const volatile* ( );
        };


      public:

        static const bool result = sizeof( BDHelper<TBase, TDerived>::
            check_sig( Host( ), 0 ) ) == sizeof( yes_type );
    };

    template <typename TBase> struct SuperSubclass<TBase, TBase>
    {
      static const bool result = true;
    };

    template <bool getType=true> struct YesNoType
    {
      static const yes_type value = 0;
    };

    template <> struct YesNoType<false>
    {
      static const no_type value = 0;
    };

    template <class T> struct UnwrapSharedPtr
    {
    };

    template <class T> struct UnwrapSharedPtr< SharedPtr<T> >
    {
      typedef T type;
    };

    template <class T, int8_t ID> struct UnwrapSharedPtr< SharedArrayPtr<T, ID> >
    {
      typedef CacheableArrayType<T, ID> type;
    };

  }
}

#define GF_UNWRAP_SP( T ) typename gemfire::TypeHelper::UnwrapSharedPtr<T>::type

#define GF_TYPE_IS_SERIALIZABLE( T ) \
  gemfire::TypeHelper::SuperSubclass<gemfire::Serializable, T>::result

#define GF_TYPE_IS_SERIALIZABLE_TYPE( T ) \
  gemfire::TypeHelper::YesNoType<GF_TYPE_IS_SERIALIZABLE( T )>::value

#define GF_SRC_IS_TARGET_TYPE( TARGET, SRC ) \
  gemfire::TypeHelper::YesNoType< gemfire::TypeHelper::SuperSubclass< TARGET, SRC >::result >::value


#endif // _GEMFIRE_TYPEHELPER_HPP_

---