CacheableBuiltins.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef GEODE_CACHEABLEBUILTINS_H_
#define GEODE_CACHEABLEBUILTINS_H_
 
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include <cstring>
 
#include "Cacheable.hpp"
#include "CacheableKey.hpp"
#include "Serializer.hpp"
#include "CacheableKeys.hpp"
#include "CacheableString.hpp"
 
namespace apache {
namespace geode {
namespace client {
 
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(apache::geode::client::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 {
    apache::geode::client::serializer::writeObject(output, m_value);
  }
 
  virtual Serializable* fromData(DataInput& input) {
    apache::geode::client::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 int32_t hashcode() const {
    return apache::geode::client::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 apache::geode::client::serializer::equals(m_value,
                                                     otherValue.m_value);
  }
 
  inline bool operator==(const TObj other) const {
    return apache::geode::client::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) {
  std::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 (static_cast<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 {
    apache::geode::client::serializer::writeObject(output, m_value, m_length);
  }
 
  virtual Serializable* fromData(DataInput& input) {
    GF_SAFE_DELETE_ARRAY(m_value);
    apache::geode::client::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 static_cast<uint32_t>(
        sizeof(CacheableArrayType) +
        apache::geode::client::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 {
    apache::geode::client::serializer::writeObject(output, *this);
  }
 
  virtual Serializable* fromData(DataInput& input) {
    apache::geode::client::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 static_cast<uint32_t>(
        sizeof(CacheableContainerType) +
        apache::geode::client::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, GeodeTypeIds::k, tName_##k, tStr_##k, sz>;              \
  typedef CacheableKeyType<p, GeodeTypeIds::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, GeodeTypeIds::c>; \
  typedef CacheableArrayType<p, GeodeTypeIds::c> _##c;    \
  class CPPCACHE_EXPORT c;                                \
  typedef SharedArrayPtr<p, GeodeTypeIds::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, GeodeTypeIds::c>; \
  typedef CacheableContainerType<p, GeodeTypeIds::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);
}  // namespace client
}  // namespace geode
}  // namespace apache
 
#endif  // GEODE_CACHEABLEBUILTINS_H_