build-artifacts/win/product/include/gfcpp/CacheableBuiltins.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_CACHEABLE_BUILTINS_HPP_
#define _GEMFIRE_CACHEABLE_BUILTINS_HPP_

/*=========================================================================
 * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */

#include "Cacheable.hpp"
#include "CacheableKey.hpp"
#include "Serializer.hpp"
#include "CacheableKeys.hpp"
#include "CacheableString.hpp"


namespace gemfire
{

  extern int gf_sprintf(char* buffer, const char* fmt, ...);

  extern int gf_snprintf(char* buffer, int32_t maxLength, const char* fmt, ...);

  template<typename TObj, int8_t TYPEID, const char* TYPENAME,
      const char* SPRINTFSYM, int32_t STRSIZE>
  class CacheableKeyType: public CacheableKey
  {
  protected:
    TObj m_value;

    inline CacheableKeyType() :
      m_value(gemfire::serializer::zeroObject<TObj>())
    {
    }

    inline CacheableKeyType(const TObj value) :
      m_value(value)
    {
    }

  public:
    inline TObj value() const
    {
      return m_value;
    }

    // Cacheable methods

    virtual void toData(DataOutput& output) const
    {
      gemfire::serializer::writeObject(output, m_value);
    }

    virtual Serializable* fromData(DataInput& input)
    {
      gemfire::serializer::readObject(input, m_value);
      return this;
    }

    virtual int32_t classId() const
    {
      return 0;
    }

    virtual int8_t typeId() const
    {
      return TYPEID;
    }

    virtual CacheableStringPtr toString() const
    {
      char buffer[STRSIZE + 1];
      gf_sprintf(buffer, SPRINTFSYM, m_value);
      return CacheableString::create(buffer);
    }

    // CacheableKey methods

    virtual uint32_t hashcode() const
    {
      return gemfire::serializer::hashcode(m_value);
    }

    virtual bool operator ==(const CacheableKey& other) const
    {
      if (other.typeId() != TYPEID) {
        return false;
      }
      const CacheableKeyType& otherValue =
          static_cast<const CacheableKeyType&> (other);
      return gemfire::serializer::equals(m_value, otherValue.m_value);
    }

    inline bool operator ==(const TObj other) const
    {
      return gemfire::serializer::equals(m_value, other);
    }

    virtual int32_t logString(char* buffer, int32_t maxLength) const
    {
      char fmt[64];
      gf_sprintf(fmt, "%s( %s )", TYPENAME, SPRINTFSYM);
      return gf_snprintf(buffer, maxLength, fmt, m_value);
    }

    virtual uint32_t objectSize() const
    {
      return sizeof(CacheableKeyType);
    }
  };

  // Forward declaration for SharedArrayPtr
  template<typename TObj, int8_t TYPEID> class SharedArrayPtr;

  template<typename TObj>
  inline void copyArray(TObj* dest, const TObj* src, int32_t length)
  {
    memcpy(dest, src, length * sizeof(TObj));
  }

  template<typename TObj>
  inline void copyArray(SharedPtr<TObj>* dest, const SharedPtr<TObj>* src,
      int32_t length)
  {
    for (int32_t index = 0; index < length; index++) {
      dest[index] = src[index];
    }
  }

  template<typename TObj, int8_t TYPEID>
  inline void copyArray(SharedArrayPtr<TObj, TYPEID>* dest,
      const SharedArrayPtr<TObj, TYPEID>* src, int32_t length)
  {
    for (int32_t index = 0; index < length; index++) {
      dest[index] = src[index];
    }
  }

  template<typename TObj, int8_t TYPEID>
  class CacheableArrayType: public Cacheable
  {
  protected:

    TObj* m_value;
    int32_t m_length;

    inline CacheableArrayType() :
      m_value(NULL), m_length(0)
    {
    }

    inline CacheableArrayType(int32_t length) :
      m_length(length)
    {
      if (length > 0) {
        GF_NEW(m_value, TObj[length]);
      }
    }

    inline CacheableArrayType(TObj* value, int32_t length) :
      m_value(value), m_length(length)
    {
    }

    inline CacheableArrayType(const TObj* value, int32_t length, bool copy) :
      m_value(NULL), m_length(length)
    {
      if (length > 0) {
        GF_NEW(m_value, TObj[length]);
        copyArray(m_value, value, length);
      }
    }

    virtual ~CacheableArrayType()
    {
      GF_SAFE_DELETE_ARRAY(m_value);
    }

  private:

    // Private to disable copy constructor and assignment operator.
    CacheableArrayType(const CacheableArrayType& other) :
        m_value(other.m_value), m_length(other.m_length)
    {
    }

    CacheableArrayType& operator =(const CacheableArrayType& other)
    {
      return *this;
    }

  public:

    inline const TObj* value() const
    {
      return m_value;
    }

    inline int32_t length() const
    {
      return m_length;
    }

    inline TObj operator [](uint32_t index) const
    {
      if ((int32_t) index >= m_length) {
        throw OutOfRangeException(
            "CacheableArray::operator[]: Index out of range.");
      }
      return m_value[index];
    }

    // Cacheable methods

    virtual void toData(DataOutput& output) const
    {
      gemfire::serializer::writeObject(output, m_value, m_length);
    }

    virtual Serializable* fromData(DataInput& input)
    {
      GF_SAFE_DELETE_ARRAY(m_value);
      gemfire::serializer::readObject(input, m_value, m_length);
      return this;
    }

    virtual int32_t classId() const
    {
      return 0;
    }

    virtual int8_t typeId() const
    {
      return TYPEID;
    }

    virtual uint32_t objectSize() const
    {
      return (uint32_t)(sizeof(CacheableArrayType)
          + gemfire::serializer::objectSize(m_value, m_length));
    }

  };

  template<typename TObj, int8_t TYPEID>
  class SharedArrayPtr: public SharedPtr<CacheableArrayType<TObj, TYPEID> >
  {
  private:

    typedef CacheableArrayType<TObj, TYPEID> TArray;

  public:

    inline SharedArrayPtr() :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > ()
    {
    }

    inline SharedArrayPtr(const TArray* ptr) :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > (ptr)
    {
    }

    inline SharedArrayPtr(const NullSharedBase* ptr) :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > (ptr)
    {
    }

    inline SharedArrayPtr(const SharedArrayPtr& other) :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > (other)
    {
    }

    template<typename TOther, int8_t OTHERID>
    inline SharedArrayPtr(const SharedArrayPtr<TOther, OTHERID>& other) :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > (other)
    {
    }

    template<typename TOther>
    inline SharedArrayPtr(const SharedPtr<TOther>& other) :
      SharedPtr<CacheableArrayType<TObj, TYPEID> > (other)
    {
    }

    inline TObj operator [](uint32_t index) const
    {
      return SharedPtr<CacheableArrayType<TObj, TYPEID> >::ptr()-> operator [](
          index);
    }

    inline Serializable * fromData(DataInput & input)
    {
      return SharedPtr<CacheableArrayType<TObj, TYPEID> >::ptr()->fromData(input);
    }
  };

  template<typename TBase, int8_t TYPEID>
  class CacheableContainerType: public Cacheable, public TBase
  {
  protected:

    inline CacheableContainerType() :
      TBase()
    {
    }

    inline CacheableContainerType(const int32_t n) :
      TBase(n)
    {
    }

  public:

    // Cacheable methods

    virtual void toData(DataOutput& output) const
    {
      gemfire::serializer::writeObject(output, *this);
    }

    virtual Serializable* fromData(DataInput& input)
    {
      gemfire::serializer::readObject(input, *this);
      return this;
    }

    virtual int32_t classId() const
    {
      return 0;
    }

    virtual int8_t typeId() const
    {
      return TYPEID;
    }

    virtual uint32_t objectSize() const
    {
      return (uint32_t)(sizeof(CacheableContainerType) +
          gemfire::serializer::objectSize(*this));
    }
  };


#ifdef _SOLARIS
#define TEMPLATE_EXPORT template class
#else
#ifdef BUILD_CPPCACHE
#define TEMPLATE_EXPORT template class CPPCACHE_EXPORT
#else
#define TEMPLATE_EXPORT extern template class CPPCACHE_EXPORT
#endif
#endif


// Disable extern template warning on MSVC compiler
#ifdef _MSC_VER
#pragma warning(disable: 4231)
#endif

#define _GF_CACHEABLE_KEY_TYPE_DEF_(p, k, sz)                           \
  extern const char tName_##k [];                                       \
  extern const char tStr_##k [];                                        \
  TEMPLATE_EXPORT CacheableKeyType<p, GemfireTypeIds::k,                \
      tName_##k, tStr_##k, sz>;                                         \
  typedef CacheableKeyType<p, GemfireTypeIds::k,                        \
    tName_##k, tStr_##k, sz> _##k;                                      \
  class CPPCACHE_EXPORT k;                                              \
  typedef SharedPtr<k> k##Ptr;

// use a class instead of typedef for bug #283
#define _GF_CACHEABLE_KEY_TYPE_(p, k, sz)                               \
  class CPPCACHE_EXPORT k: public _##k                                  \
  {                                                                     \
  protected:                                                            \
    inline k() : _##k() { }                                             \
    inline k(const p value) : _##k(value) { }                           \
  public:                                                               \
     \
    static Serializable* createDeserializable() {                       \
      return new k();                                                   \
    }                                                                   \
           \
    inline static k##Ptr create() {                                     \
      return k##Ptr(new k());                                           \
    }                                                                   \
 \
    inline static k##Ptr create(const p value) {                        \
      return k##Ptr(new k(value));                                      \
    }                                                                   \
  };                                                                    \
  inline CacheableKeyPtr createKey(const p value) {                     \
    return k::create(value);                                            \
  }                                                                     \
  inline CacheablePtr createValue(const p value) {                      \
    return k::create(value);                                            \
  }                                                                     \


#define _GF_CACHEABLE_ARRAY_TYPE_DEF_(p, c)                             \
  TEMPLATE_EXPORT CacheableArrayType<p, GemfireTypeIds::c>;             \
  typedef CacheableArrayType<p, GemfireTypeIds::c> _##c;                \
  class CPPCACHE_EXPORT c;                                              \
  typedef SharedArrayPtr<p, GemfireTypeIds::c> c##Ptr;

// use a class instead of typedef for bug #283
#define _GF_CACHEABLE_ARRAY_TYPE_(p, c)                                 \
  class CPPCACHE_EXPORT c: public _##c                                  \
  {                                                                     \
  protected:                                                            \
    inline c() : _##c() { }                                             \
    inline c(int32_t length) : _##c(length) { }                         \
    inline c(p* value, int32_t length) : _##c(value, length) { }        \
    inline c(const p* value, int32_t length, bool copy) :               \
      _##c(value, length, true) { }                                     \
  private:                                                              \
    /* Private to disable copy constructor and assignment operator. */  \
    c(const c& other);                                                  \
    c& operator =(const c& other);                                      \
  public:                                                               \
     \
    static Serializable* createDeserializable() {                       \
      return new c();                                                   \
    }                                                                   \
           \
    inline static c##Ptr create() {                                     \
      return c##Ptr(new c());                                           \
    }                                                                   \
  \
    inline static c##Ptr create(int32_t length) {                       \
      return c##Ptr(new c(length));                                     \
    }                                                                   \
       \
    inline static c##Ptr create(const p* value, int32_t length) {       \
      return (value != NULL ? c##Ptr(new c(value, length, true)) :      \
          NULLPTR);                                                     \
    }                                                                   \
                                                                 \
    inline static c##Ptr createNoCopy(p* value, int32_t length) {       \
      return (value != NULL ? c##Ptr(new c(value, length)) :            \
          NULLPTR);                                                     \
    }                                                                   \
  };


#define _GF_CACHEABLE_CONTAINER_TYPE_DEF_(p, c)                         \
  TEMPLATE_EXPORT CacheableContainerType<p, GemfireTypeIds::c>;         \
  typedef CacheableContainerType<p, GemfireTypeIds::c> _##c;            \
  class CPPCACHE_EXPORT c;                                              \
  typedef SharedPtr<c> c##Ptr;

// use a class instead of typedef for bug #283
#define _GF_CACHEABLE_CONTAINER_TYPE_(p, c)                             \
  class CPPCACHE_EXPORT c: public _##c                                  \
  {                                                                     \
  protected:                                                            \
    inline c() : _##c() { }                                             \
    inline c(const int32_t n) : _##c(n) { }                              \
  public:                                                               \
                                      \
    typedef p::Iterator Iterator;                                       \
     \
    static Serializable* createDeserializable() {                       \
      return new c();                                                   \
    }                                                                   \
               \
    inline static c##Ptr create() {                                     \
      return c##Ptr(new c());                                           \
    }                                                                   \
  \
    inline static c##Ptr create(const int32_t n) {                       \
      return c##Ptr(new c(n));                                          \
    }                                                                   \
  };



  // Instantiations for the built-in CacheableKeys

  _GF_CACHEABLE_KEY_TYPE_DEF_(bool, CacheableBoolean, 3);
  _GF_CACHEABLE_KEY_TYPE_(bool, CacheableBoolean, 3);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(bool, BooleanArray);
  _GF_CACHEABLE_ARRAY_TYPE_(bool, BooleanArray);

  _GF_CACHEABLE_KEY_TYPE_DEF_(uint8_t, CacheableByte, 15);
  _GF_CACHEABLE_KEY_TYPE_(uint8_t, CacheableByte, 15);

  _GF_CACHEABLE_KEY_TYPE_DEF_(double, CacheableDouble, 63);
  _GF_CACHEABLE_KEY_TYPE_(double, CacheableDouble, 63);

  _GF_CACHEABLE_KEY_TYPE_DEF_(float, CacheableFloat, 63);
  _GF_CACHEABLE_KEY_TYPE_(float, CacheableFloat, 63);

  _GF_CACHEABLE_KEY_TYPE_DEF_(int16_t, CacheableInt16, 15);
  _GF_CACHEABLE_KEY_TYPE_(int16_t, CacheableInt16, 15);

  _GF_CACHEABLE_KEY_TYPE_DEF_(int32_t, CacheableInt32, 15);
  _GF_CACHEABLE_KEY_TYPE_(int32_t, CacheableInt32, 15);

  _GF_CACHEABLE_KEY_TYPE_DEF_(int64_t, CacheableInt64, 31);
  _GF_CACHEABLE_KEY_TYPE_(int64_t, CacheableInt64, 31);

  _GF_CACHEABLE_KEY_TYPE_DEF_(wchar_t, CacheableWideChar, 3);
  _GF_CACHEABLE_KEY_TYPE_(wchar_t, CacheableWideChar, 3);


  _GF_CACHEABLE_ARRAY_TYPE_DEF_(wchar_t, CharArray);
  _GF_CACHEABLE_ARRAY_TYPE_(wchar_t, CharArray);

  // Instantiations for array built-in Cacheables

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(uint8_t, CacheableBytes);
  _GF_CACHEABLE_ARRAY_TYPE_(uint8_t, CacheableBytes);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(double, CacheableDoubleArray);
  _GF_CACHEABLE_ARRAY_TYPE_(double, CacheableDoubleArray);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(float, CacheableFloatArray);
  _GF_CACHEABLE_ARRAY_TYPE_(float, CacheableFloatArray);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(int16_t, CacheableInt16Array);
  _GF_CACHEABLE_ARRAY_TYPE_(int16_t, CacheableInt16Array);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(int32_t, CacheableInt32Array);
  _GF_CACHEABLE_ARRAY_TYPE_(int32_t, CacheableInt32Array);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(int64_t, CacheableInt64Array);
  _GF_CACHEABLE_ARRAY_TYPE_(int64_t, CacheableInt64Array);

  _GF_CACHEABLE_ARRAY_TYPE_DEF_(CacheableStringPtr, CacheableStringArray);
  _GF_CACHEABLE_ARRAY_TYPE_(CacheableStringPtr, CacheableStringArray);


  // Instantiations for container types (Vector/HashMap/HashSet) Cacheables

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableVector);
  _GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableVector);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable, CacheableHashMap);
  _GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable, CacheableHashMap);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashSetOfCacheableKey, CacheableHashSet);
  _GF_CACHEABLE_CONTAINER_TYPE_(_HashSetOfCacheableKey, CacheableHashSet);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableArrayList);
  _GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableArrayList);

  //linketlist for JSON formattor issue
  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableLinkedList);
  _GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableLinkedList);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableStack);
  _GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableStack);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable, CacheableHashTable);
  _GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable, CacheableHashTable);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable,
      CacheableIdentityHashMap);
  _GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable,
      CacheableIdentityHashMap);

  _GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashSetOfCacheableKey,
      CacheableLinkedHashSet);
  _GF_CACHEABLE_CONTAINER_TYPE_(_HashSetOfCacheableKey,
      CacheableLinkedHashSet);
}


#endif // _GEMFIRE_CACHEABLE_BUILTINS_HPP_

---