#pragma once

#ifndef GEODE_GFCPP_CACHEABLEBUILTINS_H_
#define GEODE_GFCPP_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.
 */

/** @file CacheableBuiltins.hpp
 *  @brief Contains generic template definitions for Cacheable types
 *         and instantiations for built-in types.
 */

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

namespace apache {
namespace geode {
namespace client {

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

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

/** Template CacheableKey class for primitive types. */
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:
  /** Gets the contained value. */
  inline TObj value() const { return m_value; }

  // Cacheable methods

  /** Serialize this object to given <code>DataOutput</code>. */
  virtual void toData(DataOutput& output) const {
    apache::geode::client::serializer::writeObject(output, m_value);
  }

  /** Deserialize this object from given <code>DataInput</code>. */
  virtual Serializable* fromData(DataInput& input) {
    apache::geode::client::serializer::readObject(input, m_value);
    return this;
  }

  /**
   * Return the classId of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int32_t classId() const { return 0; }

  /**
   * Return the typeId byte of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int8_t typeId() const { return TYPEID; }

  /** Return a string representation of the object. */
  virtual CacheableStringPtr toString() const {
    char buffer[STRSIZE + 1];
    gf_sprintf(buffer, SPRINTFSYM, m_value);
    return CacheableString::create(buffer);
  }

  // CacheableKey methods

  /** Return the hashcode for this key. */
  virtual uint32_t hashcode() const {
    return apache::geode::client::serializer::hashcode(m_value);
  }

  /** Return true if this key matches other. */
  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);
  }

  /** Return true if this key matches other key value. */
  inline bool operator==(const TObj other) const {
    return apache::geode::client::serializer::equals(m_value, other);
  }

  /**
   * Copy the string form of the object into a char* buffer for
   * logging purposes.
   */
  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);
  }

  /**
   * Return the size in bytes of the instance being serialized.
   *
   * This is used to determine whether the cache is using up more
   * physical memory than it has been configured to use. The method can
   * return zero if the user does not require the ability to control
   * cache memory utilization.
   */
  virtual uint32_t objectSize() const { return sizeof(CacheableKeyType); }
};

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

/** Function to copy an array from source to destination. */
template <typename TObj>
inline void copyArray(TObj* dest, const TObj* src, int32_t length) {
  memcpy(dest, src, length * sizeof(TObj));
}

/**
 * Function to copy an array of <code>SharedPtr</code>s from
 * source to destination.
 */
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];
  }
}

/**
 * Function to copy an array of <code>SharedArrayPtr</code>s from
 * source to destination.
 */
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 class for array of primitive types. */
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:
  /** Get the underlying array. */
  inline const TObj* value() const { return m_value; }

  /** Get the length of the array. */
  inline int32_t length() const { return m_length; }

  /** Get the element at given index. */
  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

  /** Serialize this object to the given <code>DataOutput</code>. */
  virtual void toData(DataOutput& output) const {
    apache::geode::client::serializer::writeObject(output, m_value, m_length);
  }

  /** Deserialize this object from the given <code>DataInput</code>. */
  virtual Serializable* fromData(DataInput& input) {
    GF_SAFE_DELETE_ARRAY(m_value);
    apache::geode::client::serializer::readObject(input, m_value, m_length);
    return this;
  }

  /**
   * Return the classId of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int32_t classId() const { return 0; }

  /**
   * Return the typeId byte of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int8_t typeId() const { return TYPEID; }

  /**
   * Return the size in bytes of the instance being serialized.
   *
   * This is used to determine whether the cache is using up more
   * physical memory than it has been configured to use. The method can
   * return zero if the user does not require the ability to control
   * cache memory utilization.
   */
  virtual uint32_t objectSize() const {
    return static_cast<uint32_t>(
        sizeof(CacheableArrayType) +
        apache::geode::client::serializer::objectSize(m_value, m_length));
  }
};

/**
 * Template class for CacheableArrayType SharedPtr's that adds [] operator
 */
template <typename TObj, int8_t TYPEID>
class SharedArrayPtr : public SharedPtr<CacheableArrayType<TObj, TYPEID> > {
 private:
  typedef CacheableArrayType<TObj, TYPEID> TArray;

 public:
  /** Default constructor. */
  inline SharedArrayPtr() : SharedPtr<CacheableArrayType<TObj, TYPEID> >() {}

  /** Constructor, given a pointer to array. */
  inline SharedArrayPtr(const TArray* ptr)
      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(ptr) {}

  /** Constructor, given a null SharedBase. */
  inline SharedArrayPtr(const NullSharedBase* ptr)
      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(ptr) {}

  /** Constructor, given another SharedArrayPtr. */
  inline SharedArrayPtr(const SharedArrayPtr& other)
      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}

  /** Constructor, given another kind of SharedArrayPtr. */
  template <typename TOther, int8_t OTHERID>
  inline SharedArrayPtr(const SharedArrayPtr<TOther, OTHERID>& other)
      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}

  /** Constructor, given another SharedPtr. */
  template <typename TOther>
  inline SharedArrayPtr(const SharedPtr<TOther>& other)
      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}

  /** Get the element at given index. */
  inline TObj operator[](uint32_t index) const {
    return SharedPtr<CacheableArrayType<TObj, TYPEID> >::ptr()->operator[](
        index);
  }

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

/** Template class for container Cacheable types. */
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

  /** Serialize this object to the given <code>DataOutput</code>. */
  virtual void toData(DataOutput& output) const {
    apache::geode::client::serializer::writeObject(output, *this);
  }

  /** Deserialize this object from the given <code>DataInput</code>. */
  virtual Serializable* fromData(DataInput& input) {
    apache::geode::client::serializer::readObject(input, *this);
    return this;
  }

  /**
   * Return the classId of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int32_t classId() const { return 0; }

  /**
   * Return the typeId byte of the instance being serialized.
   *
   * This is used by deserialization to determine what instance
   * type to create and deserialize into.
   */
  virtual int8_t typeId() const { return TYPEID; }

  /**
   * Return the size in bytes of the instance being serialized.
   *
   * This is used to determine whether the cache is using up more
   * physical memory than it has been configured to use. The method can
   * return zero if the user does not require the ability to control
   * cache memory utilization.
   */
  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:                                                                     \
    /** Factory function registered with serialization registry. */            \
    static Serializable* createDeserializable() { return new k(); }            \
    /** Factory function to create a new default instance. */                  \
    inline static k##Ptr create() { return k##Ptr(new k()); }                  \
    /** Factory function to create an instance with the given value. */        \
    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:                                                                     \
    /** Factory function registered with serialization registry. */            \
    static Serializable* createDeserializable() { return new c(); }            \
    /** Factory function to create a new default instance. */                  \
    inline static c##Ptr create() { return c##Ptr(new c()); }                  \
    /** Factory function to create a cacheable array of given size. */         \
    inline static c##Ptr create(int32_t length) {                              \
      return c##Ptr(new c(length));                                            \
    }                                                                          \
    /** Create a cacheable array copying from the given array. */              \
    inline static c##Ptr create(const p* value, int32_t length) {              \
      return (value != NULL ? c##Ptr(new c(value, length, true)) : NULLPTR);   \
    }                                                                          \
    /**                                                                      \ \
     * \                                                                       \
     * \ \                                                                             \
     * Create a cacheable array taking ownership of the given array          \ \
     * \                                                                       \
     * \ \                                                                             \
     * without creating a copy.                                              \ \
     * \                                                                       \
     * \ \                                                                             \
     *                                                                       \ \
     * \                                                                       \
     * \ \                                                                             \
     * Note that the application has to ensure that the given array is       \ \
     * \                                                                       \
     * \ \                                                                             \
     * not deleted (apart from this class) and is allocated on the heap      \ \
     * \                                                                       \
     * \ \                                                                             \
     * using the "new" operator.                                             \ \
     * \                                                                       \
     * \ \                                                                             \
     */                                                                        \
    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:                                                                    \
    /** Iterator for this type. */                                            \
    typedef p::Iterator Iterator;                                             \
    /** Factory function registered with serialization registry. */           \
    static Serializable* createDeserializable() { return new c(); }           \
    /** Factory function to create a default instance. */                     \
    inline static c##Ptr create() { return c##Ptr(new c()); }                 \
    /** Factory function to create an instance with the given size. */        \
    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);
/**
 * An immutable wrapper for booleans that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(bool, CacheableBoolean, 3);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(bool, BooleanArray);
/**
 * An immutable wrapper for array of booleans that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(bool, BooleanArray);

_GF_CACHEABLE_KEY_TYPE_DEF_(uint8_t, CacheableByte, 15);
/**
 * An immutable wrapper for bytes that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(uint8_t, CacheableByte, 15);

_GF_CACHEABLE_KEY_TYPE_DEF_(double, CacheableDouble, 63);
/**
 * An immutable wrapper for doubles that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(double, CacheableDouble, 63);

_GF_CACHEABLE_KEY_TYPE_DEF_(float, CacheableFloat, 63);
/**
 * An immutable wrapper for floats that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(float, CacheableFloat, 63);

_GF_CACHEABLE_KEY_TYPE_DEF_(int16_t, CacheableInt16, 15);
/**
 * An immutable wrapper for 16-bit integers that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(int16_t, CacheableInt16, 15);

_GF_CACHEABLE_KEY_TYPE_DEF_(int32_t, CacheableInt32, 15);
/**
 * An immutable wrapper for 32-bit integers that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(int32_t, CacheableInt32, 15);

_GF_CACHEABLE_KEY_TYPE_DEF_(int64_t, CacheableInt64, 31);
/**
 * An immutable wrapper for 64-bit integers that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(int64_t, CacheableInt64, 31);

_GF_CACHEABLE_KEY_TYPE_DEF_(wchar_t, CacheableWideChar, 3);
/**
 * An immutable wrapper for wide-characters that can serve as
 * a distributable key object for caching.
 */
_GF_CACHEABLE_KEY_TYPE_(wchar_t, CacheableWideChar, 3);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(wchar_t, CharArray);
/**
 * An immutable wrapper for array of wide-characters that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(wchar_t, CharArray);

// Instantiations for array built-in Cacheables

_GF_CACHEABLE_ARRAY_TYPE_DEF_(uint8_t, CacheableBytes);
/**
 * An immutable wrapper for byte arrays that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(uint8_t, CacheableBytes);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(double, CacheableDoubleArray);
/**
 * An immutable wrapper for array of doubles that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(double, CacheableDoubleArray);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(float, CacheableFloatArray);
/**
 * An immutable wrapper for array of floats that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(float, CacheableFloatArray);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(int16_t, CacheableInt16Array);
/**
 * An immutable wrapper for array of 16-bit integers that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(int16_t, CacheableInt16Array);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(int32_t, CacheableInt32Array);
/**
 * An immutable wrapper for array of 32-bit integers that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(int32_t, CacheableInt32Array);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(int64_t, CacheableInt64Array);
/**
 * An immutable wrapper for array of 64-bit integers that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(int64_t, CacheableInt64Array);

_GF_CACHEABLE_ARRAY_TYPE_DEF_(CacheableStringPtr, CacheableStringArray);
/**
 * An immutable wrapper for array of strings that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_ARRAY_TYPE_(CacheableStringPtr, CacheableStringArray);

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

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableVector);
/**
 * A mutable <code>Cacheable</code> vector wrapper that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableVector);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable, CacheableHashMap);
/**
 * A mutable <code>CacheableKey</code> to <code>Serializable</code>
 * hash map that can serve as a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable, CacheableHashMap);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashSetOfCacheableKey, CacheableHashSet);
/**
 * A mutable <code>CacheableKey</code> hash set wrapper that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_HashSetOfCacheableKey, CacheableHashSet);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableArrayList);
/**
 * A mutable <code>Cacheable</code> array list wrapper that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableArrayList);

// linketlist for JSON formattor issue
_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableLinkedList);
/**
 * A mutable <code>Cacheable</code> array list wrapper that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableLinkedList);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_VectorOfCacheable, CacheableStack);
/**
 * A mutable <code>Cacheable</code> stack wrapper that can serve as
 * a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_VectorOfCacheable, CacheableStack);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable, CacheableHashTable);
/**
 * A mutable <code>CacheableKey</code> to <code>Serializable</code>
 * hash map that can serve as a distributable object for caching.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable, CacheableHashTable);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashMapOfCacheable,
                                  CacheableIdentityHashMap);
/**
 * A mutable <code>CacheableKey</code> to <code>Serializable</code>
 * hash map that can serve as a distributable object for caching. This is
 * provided for compability with java side, though is functionally identical
 * to <code>CacheableHashMap</code> i.e. does not provide the semantics of
 * java <code>IdentityHashMap</code>.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_HashMapOfCacheable, CacheableIdentityHashMap);

_GF_CACHEABLE_CONTAINER_TYPE_DEF_(_HashSetOfCacheableKey,
                                  CacheableLinkedHashSet);
/**
 * A mutable <code>CacheableKey</code> hash set wrapper that can serve as
 * a distributable object for caching. This is provided for compability
 * with java side, though is functionally identical to
 * <code>CacheableHashSet</code> i.e. does not provide the predictable
 * iteration semantics of java <code>LinkedHashSet</code>.
 */
_GF_CACHEABLE_CONTAINER_TYPE_(_HashSetOfCacheableKey, CacheableLinkedHashSet);
}  // namespace client
}  // namespace geode
}  // namespace apache

#endif // GEODE_GFCPP_CACHEABLEBUILTINS_H_