geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject [19/51] [partial] incubator-geode git commit: Add source for geode c++ and .net clients
Date Thu, 19 May 2016 15:14:26 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableBuiltinsM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableBuiltinsM.hpp b/geode-client-native/src/clicache/CacheableBuiltinsM.hpp
new file mode 100644
index 0000000..3cf0966
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableBuiltinsM.hpp
@@ -0,0 +1,662 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/CacheableBuiltins.hpp"
+#include "CacheableKeyM.hpp"
+#include "SerializableM.hpp"
+
+#include "DataInputM.hpp"
+#include "DataOutputM.hpp"
+#include "LogM.hpp"
+
+#include "GemFireClassIdsM.hpp"
+
+using namespace System;
+using namespace GemStone::GemFire::Cache::Internal;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Template
+      {
+          [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+       ref class BultinHashcodes  
+        {
+        public :
+          static int GetHash(bool val)
+          {
+            if (val) return 1231;
+            else return 1237;
+          }
+          
+          static int GetHash(int val)
+          {
+            return val;
+          }
+
+          static int GetHash(int16 val)
+          {
+            return val;
+          }
+
+          static int GetHash(uint16 val)
+          {
+            return val;
+          }
+
+          static int GetHash(uint32 val)
+          {
+            return val;
+          }
+
+          static int GetHash(Single val)
+          {
+            return val.GetHashCode();
+          }
+
+          static int GetHash(Byte val)
+          {
+            return val;
+          }
+
+          static int GetHash(long val)
+          {
+            return val.GetHashCode();
+          }
+
+          static int GetHash(double val)
+          {
+            return val.GetHashCode();
+          }
+
+          static int GetHash(int64_t val)
+          {
+            return val.GetHashCode();
+          }
+
+          static int GetHash(Object^ val)
+          {
+            return val->GetHashCode();;
+          }
+    
+        };
+
+        /// <summary>
+        /// An immutable template wrapper for C++ <c>CacheableKey</c>s that can
+        /// serve as a distributable key object for caching.
+        /// </summary>
+       //[Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+        template <typename TNative, typename TManaged, uint32_t TYPEID>
+        public ref class CacheableBuiltinKey
+          : public GemStone::GemFire::Cache::CacheableKey
+        {
+         public:
+          /// <summary>
+          /// Allocates a new instance 
+          /// </summary>
+          /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey()
+          {
+            //TODO:Hitesh 
+            gemfire::SharedPtr<TNative>& nativeptr = TNative::create();
+            SetSP(nativeptr.ptr());
+          }
+
+          /// <summary>
+          /// Allocates a new instance with the given value.
+          /// </summary>
+          /// <param name="value">the value of the new instance</param>
+          /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey(TManaged value)
+          {
+            m_value = value;
+          }
+
+          /// <summary>
+          /// Returns the classId of the instance being serialized.
+          /// This is used by deserialization to determine what instance
+          /// type to create and deserialize into.
+          /// </summary>
+          /// <returns>the classId</returns>
+          virtual property uint32_t ClassId
+          {
+            virtual uint32_t get() override
+            {
+              return TYPEID;
+            }
+          }
+
+          virtual void ToData(GemStone::GemFire::Cache::DataOutput^ output) override
+          {
+            output->WriteObject(m_value); 
+          }
+
+          virtual GemStone::GemFire::Cache::IGFSerializable^ FromData(GemStone::GemFire::Cache::DataInput^ input) override
+          {
+              input->ReadObject(m_value);
+              return this;          
+          }
+
+          virtual property uint32_t ObjectSize 
+          {
+            virtual uint32_t get() override
+            {
+              return (uint32_t) (sizeof(m_value));
+            }
+          }
+
+          /// <summary>
+          /// Return a string representation of the object.
+          /// This returns the string for the <c>Value</c> property.
+          /// </summary>
+          virtual String^ ToString() override
+          {
+            return m_value.ToString();
+          }
+
+          /// <summary>
+          /// Return true if this key matches other object.
+          /// It invokes the '==' operator of the underlying
+          /// native object.
+          /// </summary>
+          virtual bool Equals(GemStone::GemFire::Cache::ICacheableKey^ other) override
+          {
+            if (other == nullptr || other->ClassId != TYPEID)
+            {
+              return false;
+            }
+            /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey^ otherKey =
+              dynamic_cast</*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey^>(other);
+
+            if (otherKey == nullptr)
+              return false;
+
+            return m_value.Equals(otherKey->Value);
+          }
+
+          virtual int32_t GetHashCode() override
+          {
+            //return m_value.GetHashCode();
+            return BultinHashcodes::GetHash(m_value);
+          }
+
+
+          /// <summary>
+          /// Return true if this key matches other object.
+          /// It invokes the '==' operator of the underlying
+          /// native object.
+          /// </summary>
+          virtual bool Equals(Object^ obj) override
+          {
+            /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey^ otherKey =
+              dynamic_cast</*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey^>(obj);
+
+            if (otherKey == nullptr)
+              return false;
+           
+            return m_value.Equals(otherKey->Value);
+          }
+
+          /// <summary>
+          /// Comparison operator against another value.
+          /// </summary>
+          bool operator == (TManaged other)
+          {
+            return m_value.Equals(other.Value);
+          }
+
+          /// <summary>
+          /// Gets the value.
+          /// </summary>
+          property TManaged Value
+          {
+            inline TManaged get()
+            {
+              return m_value;
+            }
+          }
+
+        protected:
+
+          TManaged m_value;
+
+          /// <summary>
+          /// Protected constructor to wrap a native object pointer
+          /// </summary>
+          /// <param name="nativeptr">The native object pointer</param>
+          inline /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey(gemfire::Serializable* nativeptr)
+            : /*GemStone::GemFire::Cache::*/CacheableKey(nativeptr) {
+              //TODO:Hitesh ??
+           m_value = static_cast<TNative*>(nativeptr)->value();
+          }
+        };
+
+
+        /// <summary>
+        /// An immutable template array wrapper that can serve as a
+        /// distributable object for caching.
+        /// </summary>
+        //[Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+        template <typename TNative, typename TNativePtr, typename TManaged,
+          uint32_t TYPEID>
+        public ref class CacheableBuiltinArray
+          : public GemStone::GemFire::Cache::Serializable
+        {
+        public:
+
+          /// <summary>
+          /// Returns the classId of the instance being serialized.
+          /// This is used by deserialization to determine what instance
+          /// type to create and deserialize into.
+          /// </summary>
+          /// <returns>the classId</returns>
+          virtual property uint32_t ClassId
+          {
+            virtual uint32_t get() override
+            {
+              return TYPEID;
+            }
+          }
+
+          virtual void ToData(GemStone::GemFire::Cache::DataOutput^ output) override
+          {
+            output->WriteObject(m_value); 
+          }
+
+          virtual GemStone::GemFire::Cache::IGFSerializable^ FromData(GemStone::GemFire::Cache::DataInput^ input) override
+          {
+            input->ReadObject(m_value);
+            return this;
+          }
+
+          virtual property uint32_t ObjectSize 
+          {
+            virtual uint32_t get() override
+            {
+              return (uint32_t) (m_value->Length * sizeof(TManaged));
+            }
+          }
+          /// <summary>
+          /// Returns a copy of the underlying array.
+          /// </summary>
+          property array<TManaged>^ Value
+          {
+            inline array<TManaged>^ get()
+            {              
+              return m_value;
+            }
+          }
+
+          /// <summary>
+          /// Returns the size of this array.
+          /// </summary>
+          property int32_t Length
+          {
+            inline int32_t get()
+            {
+              return m_value->Length;
+            }
+          }
+
+          virtual String^ ToString() override
+          {
+            return m_value->ToString();
+          }
+
+          /// <summary>
+          /// Returns the value at the given index.
+          /// </summary>
+          property TManaged GFINDEXER(int32_t)
+          {
+            inline TManaged get(int32_t index)
+            {
+              return m_value[index];
+            }
+          }
+
+
+        protected:
+
+          array<TManaged>^ m_value;
+          /// <summary>
+          /// Protected constructor 
+          /// </summary>
+          inline /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray()
+          {
+            //TODO:Hitesh
+            gemfire::Serializable* sp = TNative::createDeserializable();
+            SetSP(sp);
+          }
+
+          /// <summary>
+          /// Protected constructor to wrap a native object pointer
+          /// </summary>
+          /// <param name="nativeptr">The native object pointer</param>
+          inline /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(gemfire::Serializable* nptr)
+            : GemStone::GemFire::Cache::Serializable(nptr)
+          { 
+            //TODO:Hitesh ??
+             // ManagedPtrWrap< gemfire::Serializable,
+               // Internal::SBWrap<gemfire::Serializable> > nptr = nativeptr;
+              TNative* nativeptr = static_cast<TNative*>(nptr);
+              int32_t len = nativeptr->length();
+              if (len > 0)
+              {
+                array<TManaged>^ buffer = gcnew array<TManaged>(len);
+                pin_ptr<TManaged> pin_buffer = &buffer[0];
+
+                memcpy((void*)pin_buffer, nativeptr->value(),
+                  len * sizeof(TManaged));
+                m_value = buffer;
+              }
+          }
+
+          /// <summary>
+          /// Allocates a new instance copying from the given array.
+          /// </summary>
+          /// <remarks>
+          /// This method performs no argument checking which is the
+          /// responsibility of the caller.
+          /// </remarks>
+          /// <param name="buffer">the array to copy from</param>
+          /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(array<TManaged>^ buffer)
+          {
+            m_value = buffer;
+            //setting local value as well
+            //m_value = gcnew array<TManaged>(buffer->Length);
+            //System::Array::Copy(buffer, 0, m_value,0, buffer->Length);             
+          }
+
+          /// <summary>
+          /// Allocates a new instance copying given length from the
+          /// start of given array.
+          /// </summary>
+          /// <remarks>
+          /// This method performs no argument checking which is the
+          /// responsibility of the caller.
+          /// </remarks>
+          /// <param name="buffer">the array to copy from</param>
+          /// <param name="length">length of array from start to copy</param>
+          /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(array<TManaged>^ buffer, int32_t length)
+          {
+            //TODO:Hitesh
+            if (length > buffer->Length) {
+              length = buffer->Length;
+            }
+            //setting local value as well
+            m_value = gcnew array<TManaged>(length);
+            System::Array::Copy(buffer, 0, m_value,0, length);
+          }
+        };
+
+      }
+
+#define _GFCLI_CACHEABLE_KEY_DEF_(n, m, mt)                                   \
+      public ref class m : public /*GemStone::GemFire::Cache::*/Template::CacheableBuiltinKey<n, mt,        \
+        GemFireClassIds::m>                                                   \
+      {                                                                       \
+      public:                                                                 \
+         /** <summary>
+         *  Allocates a new instance with the given value.
+         *  </summary>
+         *  <param name="value">the value of the new instance</param>
+         */                                                                   \
+        inline m()                                                            \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey() { }                                         \
+        /** <summary>
+         *  Allocates a new instance with the given value.
+         *  </summary>
+         *  <param name="value">the value of the new instance</param>
+         */                                                                   \
+        inline m(mt value)                                                    \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey(value) { }                                    \
+        /** <summary>
+         *  Static function to create a new instance given value.
+         *  </summary>
+         *  <param name="value">the value of the new instance</param>
+         */                                                                   \
+        inline static m^ Create(mt value)                                     \
+        {                                                                     \
+          return gcnew m(value);                                              \
+        }                                                                     \
+        /** <summary>
+         * Explicit conversion operator to contained value type.
+         * </summary>
+         */                                                                   \
+        inline static explicit operator mt (m^ value)                         \
+        {                                                                     \
+          return value->Value;                                                \
+        }                                                                     \
+                                                                              \
+        /** <summary>
+         * Factory function to register this class.
+         * </summary>
+         */                                                                   \
+        static GemStone::GemFire::Cache::IGFSerializable^ CreateDeserializable()                        \
+        {                                                                     \
+          return gcnew m();                                       \
+        }                                                                     \
+                                                                              \
+      internal:                                                               \
+        static GemStone::GemFire::Cache::IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        {                                                                     \
+          return (obj != nullptr ? gcnew m(obj) : nullptr);                   \
+        }                                                                     \
+                                                                              \
+      private:                                                                \
+        inline m(gemfire::Serializable* nativeptr)                            \
+        : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinKey(nativeptr) { }                                \
+      };
+
+
+#define _GFCLI_CACHEABLE_ARRAY_DEF_(m, mt)                                    \
+      public ref class m : public GemStone::GemFire::Cache::Template::CacheableBuiltinArray<            \
+        gemfire::m, gemfire::m##Ptr, mt, GemFireClassIds::m>                  \
+      {                                                                       \
+      public:                                                                 \
+        /** <summary>
+         *  Static function to create a new instance copying
+         *  from the given array.
+         *  </summary>
+         *  <remarks>
+         *  Providing a null or zero size array will return a null object.
+         *  </remarks>
+         *  <param name="value">the array to create the new instance</param>
+         */                                                                   \
+        inline static m^ Create(array<mt>^ value)                             \
+        {                                                                     \
+          return (value != nullptr && value->Length > 0 ?                     \
+            gcnew m(value) : nullptr);                                        \
+        }                                                                     \
+        /** <summary>
+         *  Static function to create a new instance copying
+         *  from the given array.
+         *  </summary>
+         *  <remarks>
+         *  Providing a null or zero size array will return a null object.
+         *  </remarks>
+         *  <param name="value">the array to create the new instance</param>
+         */                                                                   \
+        inline static m^ Create(array<mt>^ value, int32_t length)               \
+        {                                                                     \
+          return (value != nullptr && value->Length > 0 ?                     \
+            gcnew m(value, length) : nullptr);                                \
+        }                                                                     \
+        /** <summary>
+         * Explicit conversion operator to contained array type.
+         * </summary>
+         */                                                                   \
+        inline static explicit operator array<mt>^ (m^ value)                 \
+        {                                                                     \
+          return (value != nullptr ? value->Value : nullptr);                 \
+        }                                                                     \
+                                                                              \
+        /** <summary>
+         * Factory function to register this class.
+         * </summary>
+         */                                                                   \
+        static GemStone::GemFire::Cache::IGFSerializable^ CreateDeserializable()                        \
+        {                                                                     \
+          return gcnew m();                                                   \
+        }                                                                     \
+                                                                              \
+      internal:                                                               \
+        static GemStone::GemFire::Cache::IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        {                                                                     \
+          return (obj != nullptr ? gcnew m(obj) : nullptr);                  \
+        }                                                                     \
+                                                                              \
+      private:                                                                \
+        /** <summary>
+         * Allocates a new instance
+         *  </summary>
+         */                                                                   \
+        inline m()                                                            \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray() { }                                       \
+        /** <summary>
+         * Allocates a new instance copying from the given array.
+         *  </summary>
+         *  <remarks>
+         *  Providing a null or zero size array will return a null object.
+         *  </remarks>
+         *  <param name="value">the array to create the new instance</param>
+         */                                                                   \
+        inline m(array<mt>^ value)                                            \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(value) { }                                  \
+        /** <summary>
+         * Allocates a new instance copying given length from the
+         * start of given array.
+         *  </summary>
+         *  <remarks>
+         *  Providing a null or zero size array will return a null object.
+         *  </remarks>
+         *  <param name="value">the array to create the new instance</param>
+         */                                                                   \
+        inline m(array<mt>^ value, int32_t length)                              \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(value, length) { }                          \
+        inline m(gemfire::Serializable* nativeptr)                            \
+          : /*GemStone::GemFire::Cache::Internal::*/CacheableBuiltinArray(nativeptr) { }                              \
+      };
+
+
+      // Built-in CacheableKeys
+
+      /// <summary>
+      /// An immutable wrapper for booleans that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableBoolean,
+        CacheableBoolean, bool);
+
+      /// <summary>
+      /// An immutable wrapper for bytes that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableByte,
+        CacheableByte, Byte);
+
+      /// <summary>
+      /// An immutable wrapper for 16-bit characters that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableWideChar,
+        CacheableCharacter, Char);
+
+      /// <summary>
+      /// An immutable wrapper for doubles that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableDouble,
+        CacheableDouble, Double);
+
+      /// <summary>
+      /// An immutable wrapper for floats that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableFloat,
+        CacheableFloat, Single);
+
+      /// <summary>
+      /// An immutable wrapper for 16-bit integers that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableInt16,
+        CacheableInt16, int16_t);
+
+      /// <summary>
+      /// An immutable wrapper for 32-bit integers that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableInt32,
+        CacheableInt32, int32_t);
+
+      /// <summary>
+      /// An immutable wrapper for 64-bit integers that can serve
+      /// as a distributable key object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_KEY_DEF_(gemfire::CacheableInt64,
+        CacheableInt64, int64_t);
+
+
+      // Built-in Cacheable array types
+
+      /// <summary>
+      /// An immutable wrapper for byte arrays that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableBytes, Byte);
+
+      /// <summary>
+      /// An immutable wrapper for array of doubles that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableDoubleArray, Double);
+
+      /// <summary>
+      /// An immutable wrapper for array of floats that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableFloatArray, Single);
+
+      /// <summary>
+      /// An immutable wrapper for array of 16-bit integers that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableInt16Array, int16_t);
+
+      /// <summary>
+      /// An immutable wrapper for array of 32-bit integers that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableInt32Array, int32_t);
+
+      /// <summary>
+      /// An immutable wrapper for array of 64-bit integers that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CacheableInt64Array, int64_t);
+
+      /// <summary>
+      /// An immutable wrapper for array of booleans that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(BooleanArray, bool);
+
+      /// <summary>
+      /// An immutable wrapper for array of 16-bit characters that can serve
+      /// as a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLE_ARRAY_DEF_(CharArray, Char);
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableDateM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableDateM.cpp b/geode-client-native/src/clicache/CacheableDateM.cpp
new file mode 100644
index 0000000..46bd25e
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableDateM.cpp
@@ -0,0 +1,101 @@
+/*=========================================================================
+* 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 "gf_includes.hpp"
+#include "CacheableDateM.hpp"
+#include "DataInputM.hpp"
+#include "DataOutputM.hpp"
+#include "LogM.hpp"
+//#include "GemFireClassIdsM.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      CacheableDate::CacheableDate(DateTime dateTime)
+        : m_dateTime(dateTime),m_hashcode(0)
+      {
+        // Round off dateTime to the nearest millisecond.
+        int64_t ticksToAdd = m_dateTime.Ticks % TimeSpan::TicksPerMillisecond;
+        ticksToAdd = (ticksToAdd >= (TimeSpan::TicksPerMillisecond / 2) ?
+          (TimeSpan::TicksPerMillisecond - ticksToAdd) : -ticksToAdd);
+        m_dateTime = m_dateTime.AddTicks(ticksToAdd);
+      }
+
+      void CacheableDate::ToData(DataOutput^ output)
+      {
+        TimeSpan epochSpan = m_dateTime - EpochTime;
+        int64_t millisSinceEpoch =
+          epochSpan.Ticks / TimeSpan::TicksPerMillisecond;
+        output->WriteInt64(millisSinceEpoch);
+      }
+
+      IGFSerializable^ CacheableDate::FromData(DataInput^ input)
+      {
+        DateTime epochTime = EpochTime;
+        int64_t millisSinceEpoch = input->ReadInt64();
+        m_dateTime = epochTime.AddTicks(
+          millisSinceEpoch * TimeSpan::TicksPerMillisecond);
+        return this;
+      }
+
+      uint32_t CacheableDate::ObjectSize::get()
+      { 
+        return (uint32_t)sizeof(DateTime); 
+      }
+
+      uint32_t CacheableDate::ClassId::get()
+      {
+        return GemFireClassIds::CacheableDate;
+      }
+
+      String^ CacheableDate::ToString()
+      {
+        return m_dateTime.ToString(
+          System::Globalization::CultureInfo::CurrentCulture);
+      }
+
+      int32_t CacheableDate::GetHashCode()
+      {
+        if (m_hashcode == 0) {
+          TimeSpan epochSpan = m_dateTime - EpochTime;
+          int64_t millitime =
+            epochSpan.Ticks / TimeSpan::TicksPerMillisecond;
+          m_hashcode =  (int) millitime ^ (int) ((int64)millitime >> 32);
+        }
+        return m_hashcode;
+      }
+
+      bool CacheableDate::Equals(GemStone::GemFire::Cache::ICacheableKey^ other)
+      {
+        if (other == nullptr ||
+          other->ClassId != GemFireClassIds::CacheableDate) {
+          return false;
+        }
+        return m_dateTime.Equals(static_cast<CacheableDate^>(
+          other)->m_dateTime);
+      }
+
+      bool CacheableDate::Equals(Object^ obj)
+      {
+        CacheableDate^ otherDate =
+          dynamic_cast<CacheableDate^>(obj);
+
+        if (otherDate != nullptr) {
+          return (m_dateTime == otherDate->m_dateTime);
+        }
+        return false;
+      }
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableDateM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableDateM.hpp b/geode-client-native/src/clicache/CacheableDateM.hpp
new file mode 100644
index 0000000..41c4f0f
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableDateM.hpp
@@ -0,0 +1,164 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "ICacheableKey.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      /// <summary>
+      /// An immutable date wrapper that can serve as a distributable
+      /// key object for caching as well as being a string value.
+      /// </summary>
+        [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class CacheableDate
+        : public GemStone::GemFire::Cache::ICacheableKey
+      {
+      public:
+        /// <summary>
+        /// Allocates a new default instance.
+        /// </summary>
+        inline CacheableDate()
+          : m_dateTime() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <c>CacheableDate</c> to the
+        /// given <c>System.DateTime</c> value.
+        /// </summary>
+        /// <param name="dateTime">
+        /// A <c>System.DateTime</c> value to initialize this instance.
+        /// </param>
+        CacheableDate(DateTime dateTime);
+
+        /// <summary>
+        /// Static function that returns a new default instance.
+        /// </summary>
+        inline static CacheableDate^ Create()
+        {
+          return gcnew CacheableDate();
+        }
+
+        /// <summary>
+        /// Static function that returns a new instance initialized to the
+        /// given <c>System.DateTime</c> value.
+        /// </summary>
+        inline static CacheableDate^ Create(DateTime dateTime)
+        {
+          return gcnew CacheableDate(dateTime);
+        }
+
+        // Region: IGFSerializable Members
+
+        /// <summary>
+        /// Serializes this object.
+        /// </summary>
+        /// <param name="output">
+        /// the DataOutput object to use for serializing the object
+        /// </param>
+        virtual void ToData(DataOutput^ output);
+
+        /// <summary>
+        /// Deserialize this object, typical implementation should return
+        /// the 'this' pointer.
+        /// </summary>
+        /// <param name="input">
+        /// the DataInput stream to use for reading the object data
+        /// </param>
+        /// <returns>the deserialized object</returns>
+        virtual IGFSerializable^ FromData(DataInput^ input);
+
+        /// <summary>
+        /// return the size of this object in bytes
+        /// </summary>
+        /// <summary>
+        /// return the size of this object in bytes
+        /// </summary>
+        virtual property uint32_t ObjectSize
+        {
+          virtual uint32_t get();
+        }
+
+        /// <summary>
+        /// Returns the classId of the instance being serialized.
+        /// This is used by deserialization to determine what instance
+        /// type to create and deserialize into.
+        /// </summary>
+        /// <returns>the classId</returns>
+        virtual property uint32_t ClassId
+        {
+          virtual uint32_t get();
+        }
+
+        /// <summary>
+        /// Return a string representation of the object.
+        /// </summary>
+        virtual String^ ToString() override;
+
+        // End Region: IGFSerializable Members
+
+
+        // Region: ICacheableKey Members
+
+        /// <summary>
+        /// Return the hashcode for this key.
+        /// </summary>
+        virtual int32_t GetHashCode() override;
+
+        /// <summary>
+        /// Return true if this key matches other object.
+        /// </summary>
+        virtual bool Equals(GemStone::GemFire::Cache::ICacheableKey^ other);
+
+        /// <summary>
+        /// Return true if this key matches other object.
+        /// </summary>
+        virtual bool Equals(Object^ obj) override;
+
+        // End Region: ICacheableKey Members
+
+        /// <summary>
+        /// Gets the <c>System.DateTime</c> value.
+        /// </summary>
+        property DateTime Value
+        {
+          inline DateTime get()
+          {
+            return m_dateTime;
+          }
+        }
+
+        /// <summary>
+        /// <c>DataTime</c> value since 1/1/1970
+        /// </summary>
+        static initonly DateTime EpochTime = DateTime(1970, 1, 1,
+          0, 0, 0, DateTimeKind::Utc);
+
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ CreateDeserializable()
+        {
+          return gcnew CacheableDate();
+        }
+
+      private:
+        DateTime m_dateTime;
+        int m_hashcode;
+      };
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableFileNameM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableFileNameM.cpp b/geode-client-native/src/clicache/CacheableFileNameM.cpp
new file mode 100644
index 0000000..0ecd298
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableFileNameM.cpp
@@ -0,0 +1,96 @@
+/*=========================================================================
+* 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 "gf_includes.hpp"
+#include "CacheableFileNameM.hpp"
+#include "DataOutputM.hpp"
+#include "DataInputM.hpp"
+#include "GemFireClassIdsM.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      void CacheableFileName::ToData(DataOutput^ output)
+      {
+        if (m_str->Length <= 0xFFFF) {
+          output->WriteByte(gemfire::GemfireTypeIds::CacheableString);
+          output->WriteUTF(m_str);
+        }
+        else {
+          output->WriteByte(gemfire::GemfireTypeIds::CacheableStringHuge);
+          output->WriteUTFHuge(m_str);
+        }
+      }
+
+      IGFSerializable^ CacheableFileName::FromData(DataInput^ input)
+      {
+        unsigned char filetype = input->ReadByte();
+        if (filetype == gemfire::GemfireTypeIds::CacheableString) {
+          m_str = input->ReadUTF();
+        }
+        else {
+          m_str = input->ReadUTFHuge();
+        }
+        return this;
+      }
+
+      uint32_t CacheableFileName::ClassId::get()
+      {
+        return GemFireClassIds::CacheableFileName;
+      }
+
+      uint32_t CacheableFileName::ObjectSize::get()
+      {
+        return (uint32_t)(m_str->Length * sizeof(char));
+      }
+
+      int32_t CacheableFileName::GetHashCode()
+      {
+        if (m_str->IsNullOrEmpty(m_str)) {
+          return 0;
+        }
+        if (m_hashcode == 0) {
+          int localHashcode = 0;          
+          uint32_t prime = 31;
+
+          pin_ptr<const wchar_t> pin_value = PtrToStringChars( m_str );
+          for (int32_t i = 0; i < m_str->Length; i++) {
+            localHashcode = prime*localHashcode + Char::ToLower(pin_value[i]);
+          }    
+          m_hashcode  = localHashcode ^ 1234321;
+        }
+        return m_hashcode;
+      }
+
+      bool CacheableFileName::Equals(GemStone::GemFire::Cache::ICacheableKey^ other)
+      {
+        if (other == nullptr ||
+          other->ClassId != GemFireClassIds::CacheableFileName) {
+          return false;
+        }
+        return (m_str == static_cast<CacheableFileName^>(other)->m_str);
+      }
+
+      bool CacheableFileName::Equals(Object^ obj)
+      {
+        CacheableFileName^ otherFileName =
+          dynamic_cast<CacheableFileName^>(obj);
+
+        if (otherFileName != nullptr) {
+          return (m_str == otherFileName->m_str);
+        }
+        return false;
+      }
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableFileNameM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableFileNameM.hpp b/geode-client-native/src/clicache/CacheableFileNameM.hpp
new file mode 100644
index 0000000..c998281
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableFileNameM.hpp
@@ -0,0 +1,159 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "ICacheableKey.hpp"
+
+
+using namespace System;
+
+using namespace GemStone::GemFire::Cache;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      /// <summary>
+      /// An immutable filename wrapper that can serve as a distributable
+      /// key object for caching as well as being a string value.
+      /// </summary>
+        [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class CacheableFileName : public ICacheableKey
+      {
+      public:
+        /// <summary>
+        /// Static function to create a new instance from the given string.
+        /// </summary>
+        inline static CacheableFileName^ Create(String^ value)
+        {
+          return (value != nullptr && value->Length > 0 ?
+            gcnew CacheableFileName(value) : nullptr);
+        }
+
+        /// <summary>
+        /// Static function to create a new instance from the
+        /// given character array.
+        /// </summary>
+        inline static CacheableFileName^ Create(array<Char>^ value)
+        {
+          return (value != nullptr && value->Length > 0 ?
+            gcnew CacheableFileName(value) : nullptr);
+        }
+
+        // Region: IGFSerializable Members
+
+        /// <summary>
+        /// Serializes this object.
+        /// </summary>
+        /// <param name="output">
+        /// the DataOutput object to use for serializing the object
+        /// </param>
+        virtual void ToData(DataOutput^ output);
+
+        /// <summary>
+        /// Deserialize this object, typical implementation should return
+        /// the 'this' pointer.
+        /// </summary>
+        /// <param name="input">
+        /// the DataInput stream to use for reading the object data
+        /// </param>
+        /// <returns>the deserialized object</returns>
+        virtual IGFSerializable^ FromData(DataInput^ input);
+
+        /// <summary>
+        /// return the size of this object in bytes
+        /// </summary>
+        virtual property uint32_t ObjectSize
+        {
+          virtual uint32_t get();
+        }
+
+        /// <summary>
+        /// Returns the classId of the instance being serialized.
+        /// This is used by deserialization to determine what instance
+        /// type to create and deserialize into.
+        /// </summary>
+        /// <returns>the classId</returns>
+        virtual property uint32_t ClassId
+        {
+          virtual uint32_t get();
+        }
+
+        /// <summary>
+        /// Return a string representation of the object.
+        /// This returns the same string as <c>Value</c> property.
+        /// </summary>
+        virtual String^ ToString() override
+        {
+          return m_str;
+        }
+
+        // End Region: IGFSerializable Members
+
+        // Region: ICacheableKey Members
+
+        /// <summary>
+        /// Return the hashcode for this key.
+        /// </summary>
+        virtual int32_t GetHashCode() override;
+
+        /// <summary>
+        /// Return true if this key matches other object.
+        /// </summary>
+        virtual bool Equals(ICacheableKey^ other);
+
+        /// <summary>
+        /// Return true if this key matches other object.
+        /// </summary>
+        virtual bool Equals(Object^ obj) override;
+
+        // End Region: ICacheableKey Members
+
+        /// <summary>
+        /// Gets the string value.
+        /// </summary>
+        property String^ Value
+        {
+          inline String^ get()
+          {
+            return m_str;
+          }
+        }
+
+      internal:
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ CreateDeserializable()
+        {
+          return gcnew CacheableFileName((String^)nullptr);
+        }
+
+      private:
+        /// <summary>
+        /// Allocates a new instance from the given string.
+        /// </summary>
+        inline CacheableFileName(String^ value)
+          : m_str(value == nullptr ? String::Empty : value),m_hashcode(0) { }
+
+        /// <summary>
+        /// Allocates a new instance copying from the given character array.
+        /// </summary>
+        inline CacheableFileName(array<Char>^ value)
+          : m_str(gcnew String(value)),m_hashcode(0) { }
+
+        String^ m_str;
+        int m_hashcode;
+      };
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableHashMapM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableHashMapM.cpp b/geode-client-native/src/clicache/CacheableHashMapM.cpp
new file mode 100644
index 0000000..212b86a
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableHashMapM.cpp
@@ -0,0 +1,68 @@
+/*=========================================================================
+ * 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 "gf_includes.hpp"
+#include "CacheableHashMapM.hpp"
+#include "DataOutputM.hpp"
+#include "DataInputM.hpp"
+
+
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      // Region: IGFSerializable Members
+
+      void CacheableHashMap::ToData(DataOutput^ output)
+      {
+        output->WriteArrayLen(this->Count);
+        for each (KeyValuePair<GemStone::GemFire::Cache::ICacheableKey^, IGFSerializable^> keyValPair in this) 
+        {
+          output->WriteObject(keyValPair.Key);
+          output->WriteObject(keyValPair.Value);
+        }        
+      }
+
+      IGFSerializable^ CacheableHashMap::FromData(DataInput^ input)
+      {
+        int len = input->ReadArrayLen();
+        if (len > 0)
+        {
+          for ( int i = 0; i < len; i++)
+          {
+            GemStone::GemFire::Cache::ICacheableKey^ key =
+              dynamic_cast<GemStone::GemFire::Cache::ICacheableKey^>(input->ReadObject());
+            IGFSerializable^ value = input->ReadObject();
+            this->Add(key, value);
+          }
+        }
+        return this;
+      }
+
+      uint32_t CacheableHashMap::ObjectSize::get()
+      {
+        uint32_t size = 0;
+        for each (KeyValuePair<GemStone::GemFire::Cache::ICacheableKey^, IGFSerializable^> keyValPair
+          in this) {
+          size += keyValPair.Key->ObjectSize;
+          if (keyValPair.Value != nullptr) {
+            size += keyValPair.Value->ObjectSize;
+          }
+        }
+        return size;
+      }
+
+      // End Region: IGFSerializable Members
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableHashMapM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableHashMapM.hpp b/geode-client-native/src/clicache/CacheableHashMapM.hpp
new file mode 100644
index 0000000..db29a01
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableHashMapM.hpp
@@ -0,0 +1,145 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "IGFSerializable.hpp"
+#include "ICacheableKey.hpp"
+#include "GemFireClassIdsM.hpp"
+
+
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      /// <summary>
+      /// A mutable <c>ICacheableKey</c> to <c>IGFSerializable</c> hash map
+      /// that can serve as a distributable object for caching. This class
+      /// extends .NET generic <c>Dictionary</c> class.
+      /// </summary>
+        [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class CacheableHashMap
+        : public Dictionary<ICacheableKey^, IGFSerializable^>,
+        public IGFSerializable
+      {
+      public:
+        /// <summary>
+        /// Allocates a new empty instance.
+        /// </summary>
+        inline CacheableHashMap()
+          : Dictionary<ICacheableKey^, IGFSerializable^>()
+        { }
+
+        /// <summary>
+        /// Allocates a new instance copying from the given dictionary.
+        /// </summary>
+        /// <param name="dictionary">
+        /// The dictionary whose elements are copied to this HashMap.
+        /// </param>
+        inline CacheableHashMap(System::Collections::Generic::IDictionary<ICacheableKey^, IGFSerializable^>^
+          dictionary)
+          : Dictionary<ICacheableKey^, IGFSerializable^>(dictionary)
+        { }
+
+        /// <summary>
+        /// Allocates a new empty instance with given initial size.
+        /// </summary>
+        /// <param name="capacity">
+        /// The initial capacity of the HashMap.
+        /// </param>
+        inline CacheableHashMap(int32_t capacity)
+          : Dictionary<ICacheableKey^, IGFSerializable^>(capacity)
+        { }
+
+        /// <summary>
+        /// Static function to create a new empty instance.
+        /// </summary>
+        inline static CacheableHashMap^ Create()
+        {
+          return gcnew CacheableHashMap();
+        }
+
+        /// <summary>
+        /// Static function to create a new instance copying from the
+        /// given dictionary.
+        /// </summary>
+        inline static CacheableHashMap^ Create(
+          System::Collections::Generic::IDictionary<ICacheableKey^, IGFSerializable^>^ dictionary)
+        {
+          return gcnew CacheableHashMap(dictionary);
+        }
+
+        /// <summary>
+        /// Static function to create a new instance with given initial size.
+        /// </summary>
+        inline static CacheableHashMap^ Create(int32_t capacity)
+        {
+          return gcnew CacheableHashMap(capacity);
+        }
+
+        // Region: IGFSerializable Members
+
+        /// <summary>
+        /// Serializes this object.
+        /// </summary>
+        /// <param name="output">
+        /// the DataOutput object to use for serializing the object
+        /// </param>
+        virtual void ToData(DataOutput^ output);
+
+        /// <summary>
+        /// Deserialize this object, typical implementation should return
+        /// the 'this' pointer.
+        /// </summary>
+        /// <param name="input">
+        /// the DataInput stream to use for reading the object data
+        /// </param>
+        /// <returns>the deserialized object</returns>
+        virtual IGFSerializable^ FromData(DataInput^ input);
+
+        /// <summary>
+        /// return the size of this object in bytes
+        /// </summary>
+        virtual property uint32_t ObjectSize
+        {
+          virtual uint32_t get();
+        }
+
+        /// <summary>
+        /// Returns the classId of the instance being serialized.
+        /// This is used by deserialization to determine what instance
+        /// type to create and deserialize into.
+        /// </summary>
+        /// <returns>the classId</returns>
+        virtual property uint32_t ClassId
+        {
+          inline virtual uint32_t get()
+          {
+            return GemFireClassIds::CacheableHashMap;
+          }
+        }
+
+        // End Region: IGFSerializable Members
+
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ CreateDeserializable()
+        {
+          return gcnew CacheableHashMap();
+        }
+      };
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableHashSetM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableHashSetM.hpp b/geode-client-native/src/clicache/CacheableHashSetM.hpp
new file mode 100644
index 0000000..fd0b256
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableHashSetM.hpp
@@ -0,0 +1,551 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/CacheableBuiltins.hpp"
+#include "SerializableM.hpp"
+#include "ICacheableKey.hpp"
+
+using namespace System;
+using namespace System::Collections;
+using namespace System::Collections::Generic;
+
+//#pragma managed
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Internal
+      {
+        /// <summary>
+        /// A mutable <c>ICacheableKey</c> hash set wrapper that can serve as
+        /// a distributable object for caching.
+        /// </summary>
+          //[Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+        template <uint32_t TYPEID, typename HSTYPE>
+        public ref class CacheableHashSetType
+          : public Serializable,
+            public System::Collections::Generic::ICollection<ICacheableKey^>
+        {
+        public:
+
+        virtual void ToData(DataOutput^ output) override
+        {
+          output->WriteArrayLen(this->Count);
+
+          Internal::ManagedPtrWrap< gemfire::Serializable,
+              Internal::SBWrap<gemfire::Serializable> > nptr = NativePtr;
+          HSTYPE* set = static_cast<HSTYPE*>(nptr());
+          for (typename HSTYPE::Iterator iter = set->begin();
+              iter != set->end(); ++iter) {
+                GemStone::GemFire::Cache::ICacheableKey^ key = SafeUMKeyConvert((*iter).ptr());
+            output->WriteObject(key);
+          }
+        }
+
+        virtual IGFSerializable^ FromData(DataInput^ input) override
+        {
+          int len = input->ReadArrayLen();
+          if (len > 0)
+          {
+            for ( int i = 0; i < len; i++)
+            {
+              GemStone::GemFire::Cache::ICacheableKey^ key =
+                dynamic_cast<GemStone::GemFire::Cache::ICacheableKey^>(input->ReadObject());
+              this->Add(key);
+            }
+          }
+          return this;
+        }
+
+        virtual property uint32_t ObjectSize 
+        {
+          virtual uint32_t get() override
+          {
+            uint32_t size = 0;
+            for each (GemStone::GemFire::Cache::ICacheableKey^ key in this) {
+              if ( key != nullptr)
+                size += key->ObjectSize; 
+            }
+            return size;
+          }
+        }        
+
+          /// <summary>
+          /// Enumerator for <c>CacheableHashSet</c> class.
+          /// </summary>
+          ref class Enumerator sealed
+            : public Internal::UMWrap<typename HSTYPE::Iterator>,
+            public System::Collections::Generic::IEnumerator<ICacheableKey^>
+          {
+          public:                 
+
+            // Region: IEnumerator<ICacheableKey^> Members
+
+            /// <summary>
+            /// Gets the element in the collection at the current
+            /// position of the enumerator.
+            /// </summary>
+            /// <returns>
+            /// The element in the collection at the current position
+            /// of the enumerator.
+            /// </returns>
+            property ICacheableKey^ Current
+            {
+              virtual ICacheableKey^ get() =
+                System::Collections::Generic::IEnumerator<ICacheableKey^>::Current::get
+              {
+                if (!m_started) {
+                  throw gcnew System::InvalidOperationException(
+                    "Call MoveNext first.");
+                }
+                return SafeUMKeyConvert((*(*NativePtr())).ptr());
+              }
+            }
+
+            // End Region: IEnumerator<ICacheableKey^> Members
+
+            // Region: IEnumerator Members
+
+            /// <summary>
+            /// Advances the enumerator to the next element of the collection.
+            /// </summary>
+            /// <returns>
+            /// true if the enumerator was successfully advanced to the next
+            /// element; false if the enumerator has passed the end of
+            /// the collection.
+            /// </returns>
+            virtual bool MoveNext()
+            {
+              Internal::ManagedPtrWrap< typename HSTYPE::Iterator,
+                Internal::UMWrap<typename HSTYPE::Iterator> > nptr = NativePtr;
+              bool isEnd = nptr->isEnd();
+              if (!m_started) {
+                m_started = true;
+              }
+              else {
+                if (!isEnd) {
+                  (*nptr())++;
+                  isEnd = nptr->isEnd();
+                }
+              }
+              GC::KeepAlive(this);
+              return !isEnd;
+            }
+
+            /// <summary>
+            /// Sets the enumerator to its initial position, which is before
+            /// the first element in the collection.
+            /// </summary>
+            virtual void Reset()
+            {
+              NativePtr->reset();
+              m_started = false;
+            }
+
+            // End Region: IEnumerator Members
+
+          internal:
+            /// <summary>
+            /// Internal constructor to wrap a native object pointer
+            /// </summary>
+            /// <param name="nativeptr">The native object pointer</param>
+            inline Enumerator(typename HSTYPE::Iterator* nativeptr,
+                CacheableHashSetType<TYPEID, HSTYPE>^ set)
+              : Internal::UMWrap<typename HSTYPE::Iterator>(nativeptr, true), m_set(set) { }
+
+          internal: // private:
+            // Region: IEnumerator Members
+
+            /// <summary>
+            /// Gets the current element in the collection.
+            /// </summary>
+            /// <returns>
+            ///     The current element in the collection.
+            /// </returns>
+            /// <exception cref="System.InvalidOperationException">
+            /// The enumerator is positioned before the first element of
+            /// the collection or after the last element.
+            /// </exception>
+            property Object^ ICurrent
+            {
+              virtual Object^ get() sealed =
+                System::Collections::IEnumerator::Current::get
+              {
+                return Current;
+              }
+            }
+
+            // End Region: IEnumerator Members
+
+            bool m_started;
+
+            CacheableHashSetType<TYPEID, HSTYPE>^ m_set;
+          };
+
+          /// <summary>
+          /// Returns the classId of the instance being serialized.
+          /// This is used by deserialization to determine what instance
+          /// type to create and deserialize into.
+          /// </summary>
+          /// <returns>the classId</returns>
+          virtual property uint32_t ClassId
+          {
+            virtual uint32_t get() override
+            {
+              //return static_cast<HSTYPE*>(NativePtr())->classId() + 0x80000000;
+              return TYPEID;
+            }
+          }
+
+          /// <summary>
+          /// Get the largest possible size of the <c>CacheableHashSet</c>.
+          /// </summary>
+          property int32_t MaxSize
+          {
+            inline int32_t get()
+            {
+              return static_cast<HSTYPE*>(NativePtr())->max_size();
+            }
+          }
+
+          /// <summary>
+          /// True if the <c>CacheableHashSet</c>'s size is 0.
+          /// </summary>
+          property bool IsEmpty
+          {
+            inline bool get()
+            {
+              return static_cast<HSTYPE*>(NativePtr())->empty();
+            }
+          }
+
+          /// <summary>
+          /// Get the number of buckets used by the HashSet.
+          /// </summary>
+          property int32_t BucketCount
+          {
+            inline int32_t get()
+            {
+              return static_cast<HSTYPE*>(NativePtr())->bucket_count();
+            }
+          }
+
+          /// <summary>
+          /// Increases the bucket count to at least <c>size</c> elements.
+          /// </summary>
+          /// <param name="size">The new size of the HashSet.</param>
+          virtual void Resize(int32_t size) sealed
+          {
+            static_cast<HSTYPE*>(NativePtr())->resize(size);
+          }
+
+          /// <summary>
+          /// Swap the contents of this <c>CacheableHashSet</c>
+          /// with the given one.
+          /// </summary>
+          /// <param name="other">
+          /// The other CacheableHashSet to use for swapping.
+          /// </param>
+          virtual void Swap(CacheableHashSetType<TYPEID, HSTYPE>^ other) sealed
+          {
+            if (other != nullptr) {
+              static_cast<HSTYPE*>(NativePtr())->swap(
+                *static_cast<HSTYPE*>(other->NativePtr()));
+            }
+          }
+
+          // Region: ICollection<ICacheableKey^> Members
+
+          /// <summary>
+          /// Adds an item to the <c>CacheableHashSet</c>.
+          /// </summary>
+          /// <param name="item">
+          /// The object to add to the collection.
+          /// </param>
+          virtual void Add(ICacheableKey^ item)
+          {
+            _GF_MG_EXCEPTION_TRY
+
+              gemfire::CacheableKeyPtr nativeptr(SafeMKeyConvert(item));
+            static_cast<HSTYPE*>(NativePtr())->insert(nativeptr);
+
+            _GF_MG_EXCEPTION_CATCH_ALL
+          }
+
+          /// <summary>
+          /// Removes all items from the <c>CacheableHashSet</c>.
+          /// </summary>
+          virtual void Clear()
+          {
+            static_cast<HSTYPE*>(NativePtr())->clear();
+          }
+
+          /// <summary>
+          /// Determines whether the <c>CacheableHashSet</c> contains
+          /// a specific value.
+          /// </summary>
+          /// <param name="item">
+          /// The object to locate in the <c>CacheableHashSet</c>.
+          /// </param>
+          /// <returns>
+          /// true if item is found in the <c>CacheableHashSet</c>;
+          /// otherwise false.
+          /// </returns>
+          virtual bool Contains(ICacheableKey^ item)
+          {
+            return static_cast<HSTYPE*>(NativePtr())->contains(
+              gemfire::CacheableKeyPtr(SafeMKeyConvert(item)));
+          }
+
+          /// <summary>
+          /// Copies the elements of the <c>CacheableHashSet</c> to an
+          /// <c>System.Array</c>, starting at a particular
+          /// <c>System.Array</c> index.
+          /// </summary>
+          /// <param name="array">
+          /// The one-dimensional System.Array that is the destination of the
+          /// elements copied from <c>CacheableHashSet</c>. The
+          /// <c>System.Array</c> must have zero-based indexing.
+          /// </param>
+          /// <param name="arrayIndex">
+          /// The zero-based index in array at which copying begins.
+          /// </param>
+          /// <exception cref="IllegalArgumentException">
+          /// arrayIndex is less than 0 or array is null.
+          /// </exception>
+          /// <exception cref="OutOfRangeException">
+          /// arrayIndex is equal to or greater than the length of array.
+          /// -or-The number of elements in the source <c>CacheableHashSet</c>
+          /// is greater than the available space from arrayIndex to the end
+          /// of the destination array.
+          /// </exception>
+          virtual void CopyTo(array<ICacheableKey^>^ array, int32_t arrayIndex)
+          {
+            if (array == nullptr || arrayIndex < 0) {
+              throw gcnew IllegalArgumentException("CacheableHashSet.CopyTo():"
+                " array is null or array index is less than zero");
+            }
+            Internal::ManagedPtrWrap< gemfire::Serializable,
+              Internal::SBWrap<gemfire::Serializable> > nptr = NativePtr;
+            HSTYPE* set = static_cast<HSTYPE*>(nptr());
+            int32_t index = arrayIndex;
+
+            if (arrayIndex >= array->Length ||
+              array->Length < (arrayIndex + (int32_t)set->size())) {
+                throw gcnew OutOfRangeException("CacheableHashSet.CopyTo():"
+                  " array index is beyond the HashSet or length of given "
+                  "array is less than that required to copy all the "
+                  "elements from HashSet");
+            }
+            for (typename HSTYPE::Iterator iter = set->begin();
+              iter != set->end(); ++iter, ++index) {
+                array[index] = SafeUMKeyConvert((*iter).ptr());
+            }
+            GC::KeepAlive(this);
+          }
+
+          /// <summary>
+          /// Gets the number of elements contained in the
+          /// <c>CacheableHashSet</c>.
+          /// </summary>
+          virtual property int32_t Count
+          {
+            virtual int32_t get()
+            {
+              return static_cast<HSTYPE*>(NativePtr())->size();
+            }
+          }
+
+          /// <summary>
+          /// Removes the first occurrence of a specific object from the
+          /// <c>CacheableHashSet</c>.
+          /// </summary>
+          /// <param name="item">
+          /// The object to remove from the <c>CacheableHashSet</c>.
+          /// </param>
+          /// <returns>
+          /// true if item was successfully removed from the
+          /// <c>CacheableHashSet</c>; otherwise, false. This method also
+          /// returns false if item is not found in the original
+          /// <c>CacheableHashSet</c>.
+          /// </returns>
+          virtual bool Remove(ICacheableKey^ item)
+          {
+            return (static_cast<HSTYPE*>(NativePtr())->erase(
+              gemfire::CacheableKeyPtr(SafeMKeyConvert(item))) > 0);
+          }
+
+          /// <summary>
+          /// Gets a value indicating whether the collection is read-only.
+          /// </summary>
+          /// <returns>
+          /// always false for <c>CacheableHashSet</c>
+          /// </returns>
+          virtual property bool IsReadOnly
+          {
+            virtual bool get()
+            {
+              return false;
+            }
+          }
+
+          // End Region: ICollection<ICacheableKey^> Members
+
+          // Region: IEnumerable<ICacheableKey^> Members
+
+          /// <summary>
+          /// Returns an enumerator that iterates through the
+          /// <c>CacheableHashSet</c>.
+          /// </summary>
+          /// <returns>
+          /// A <c>System.Collections.Generic.IEnumerator</c> that
+          /// can be used to iterate through the <c>CacheableHashSet</c>.
+          /// </returns>
+          virtual System::Collections::Generic::IEnumerator<ICacheableKey^>^ GetEnumerator()
+          {
+            typename HSTYPE::Iterator* iter = new typename HSTYPE::Iterator(
+              static_cast<HSTYPE*>(NativePtr())->begin());
+
+            return gcnew Enumerator(iter, this);
+          }
+
+          // End Region: IEnumerable<ICacheableKey^> Members
+
+        internal:
+          /// <summary>
+          /// Factory function to register wrapper
+          /// </summary>
+          static IGFSerializable^ Create(gemfire::Serializable* obj)
+          {
+            return (obj != NULL ?
+              gcnew CacheableHashSetType<TYPEID,HSTYPE>(obj) : nullptr);
+          }
+
+        internal: //private:
+          // Region: IEnumerable Members
+
+          /// <summary>
+          /// Returns an enumerator that iterates through a collection.
+          /// </summary>
+          /// <returns>
+          /// An <c>System.Collections.IEnumerator</c> object that can be used
+          /// to iterate through the collection.
+          /// </returns>
+          virtual System::Collections::IEnumerator^ GetIEnumerator() sealed =
+            System::Collections::IEnumerable::GetEnumerator
+          {
+            return GetEnumerator();
+          }
+
+          // End Region: IEnumerable Members
+
+        protected:
+          /// <summary>
+          /// Private constructor to wrap a native object pointer
+          /// </summary>
+          /// <param name="nativeptr">The native object pointer</param>
+          inline CacheableHashSetType<TYPEID, HSTYPE>(gemfire::Serializable* nativeptr)
+            : Serializable(nativeptr) { }
+
+          /// <summary>
+          /// Allocates a new empty instance.
+          /// </summary>
+          inline CacheableHashSetType<TYPEID, HSTYPE>()
+            : Serializable(HSTYPE::createDeserializable())
+          { }
+
+          /// <summary>
+          /// Allocates a new empty instance with given initial size.
+          /// </summary>
+          /// <param name="size">The initial size of the HashSet.</param>
+          inline CacheableHashSetType<TYPEID,HSTYPE>(int32_t size)
+            : Serializable(HSTYPE::create(size).ptr())
+          { }
+        };
+      }
+
+#define _GFCLI_CACHEABLEHASHSET_DEF_(m, HSTYPE)                               \
+      public ref class m : public Internal::CacheableHashSetType<GemStone::GemFire::Cache::GemFireClassIds::m, HSTYPE>      \
+      {                                                                       \
+      public:                                                                 \
+        /** <summary>
+         *  Allocates a new empty instance.
+         *  </summary>
+         */                                                                   \
+        inline m()                                                            \
+           : Internal::CacheableHashSetType<GemStone::GemFire::Cache::GemFireClassIds::m, HSTYPE>() {}                      \
+                                                                              \
+        /** <summary>
+         *  Allocates a new instance with the given size.
+         *  </summary>
+         *  <param name="size">the intial size of the new instance</param>
+         */                                                                   \
+        inline m(int32_t size)                                                 \
+           : Internal::CacheableHashSetType<GemStone::GemFire::Cache::GemFireClassIds::m, HSTYPE>(size) {}                  \
+                                                                              \
+        /** <summary>
+         *  Static function to create a new empty instance.
+         *  </summary>
+         */                                                                   \
+        inline static m^ Create()                                             \
+        {                                                                     \
+          return gcnew m();                                                   \
+        }                                                                     \
+                                                                              \
+        /** <summary>
+         *  Static function to create a new instance with the given size.
+         *  </summary>
+         */                                                                   \
+        inline static m^ Create(int32_t size)                                  \
+        {                                                                     \
+          return gcnew m(size);                                               \
+        }                                                                     \
+                                                                              \
+        /* <summary>
+         * Factory function to register this class.
+         * </summary>
+         */                                                                   \
+        static IGFSerializable^ CreateDeserializable()                        \
+        {                                                                     \
+          return gcnew m();                                                   \
+        }                                                                     \
+                                                                              \
+      internal:                                                               \
+        static IGFSerializable^ Create(gemfire::Serializable* obj)            \
+        {                                                                     \
+          return gcnew m(obj);                                                \
+        }                                                                     \
+                                                                              \
+      internal: /* private: */                                                \
+        inline m(gemfire::Serializable* nativeptr)                            \
+          : Internal::CacheableHashSetType<GemStone::GemFire::Cache::GemFireClassIds::m, HSTYPE>(nativeptr) { }             \
+      };
+
+      /// <summary>
+      /// A mutable <c>ICacheableKey</c> hash set wrapper that can serve as
+      /// a distributable object for caching.
+      /// </summary>
+      _GFCLI_CACHEABLEHASHSET_DEF_(CacheableHashSet, gemfire::CacheableHashSet);
+
+      /// <summary>
+      /// A mutable <c>ICacheableKey</c> 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
+      /// <c>CacheableHashSet</c> i.e. does not provide the linked semantics of
+      /// java <c>LinkedHashSet</c>.
+      /// </summary>
+      _GFCLI_CACHEABLEHASHSET_DEF_(CacheableLinkedHashSet, gemfire::CacheableLinkedHashSet);
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableHashTableM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableHashTableM.hpp b/geode-client-native/src/clicache/CacheableHashTableM.hpp
new file mode 100644
index 0000000..d41be2b
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableHashTableM.hpp
@@ -0,0 +1,103 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "CacheableHashMapM.hpp"
+
+
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      /// <summary>
+      /// A mutable <c>ICacheableKey</c> to <c>IGFSerializable</c> hash table
+      /// that can serve as a distributable object for caching. This class
+      /// extends .NET generic <c>Dictionary</c> class.
+      /// </summary>
+        [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class CacheableHashTable
+        : public CacheableHashMap
+      {
+      public:
+
+        /// <summary>
+        /// Allocates a new empty instance.
+        /// </summary>
+        inline CacheableHashTable()
+          : CacheableHashMap()
+        { }
+
+        /// <summary>
+        /// Allocates a new instance copying from the given dictionary.
+        /// </summary>
+        /// <param name="dictionary">
+        /// The dictionary whose elements are copied to this HashTable.
+        /// </param>
+        inline CacheableHashTable(System::Collections::Generic::IDictionary<ICacheableKey^,
+          IGFSerializable^>^ dictionary)
+          : CacheableHashMap(dictionary)
+        { }
+
+        /// <summary>
+        /// Allocates a new empty instance with given initial size.
+        /// </summary>
+        /// <param name="capacity">
+        /// The initial capacity of the HashTable.
+        /// </param>
+        inline CacheableHashTable(int32_t capacity)
+          : CacheableHashMap(capacity)
+        { }
+
+
+        // Region: IGFSerializable Members
+
+        /// <summary>
+        /// Returns the classId of the instance being serialized.
+        /// This is used by deserialization to determine what instance
+        /// type to create and deserialize into.
+        /// </summary>
+        /// <returns>the classId</returns>
+        virtual property uint32_t ClassId
+        {
+          virtual uint32_t get() override
+          {
+            return GemFireClassIds::CacheableHashTable;
+          }
+        }
+
+        // End Region: IGFSerializable Members
+
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ CreateDeserializable()
+        {
+          return gcnew CacheableHashTable();
+        }
+
+      internal:
+
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ Create()
+        {
+          return gcnew CacheableHashTable();
+        }
+      };
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableIdentityHashMapM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableIdentityHashMapM.hpp b/geode-client-native/src/clicache/CacheableIdentityHashMapM.hpp
new file mode 100644
index 0000000..0cf078b
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableIdentityHashMapM.hpp
@@ -0,0 +1,119 @@
+/*=========================================================================
+ * 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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "CacheableHashMapM.hpp"
+#include "ICacheableKey.hpp"
+
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      /// <summary>
+      /// A mutable <c>ICacheableKey</c> to <c>IGFSerializable</c> hash map
+      /// that can serve as a distributable object for caching. This class
+      /// extends .NET generic <c>Dictionary</c> class. This class is meant
+      /// as a means to interoperate with java server side
+      /// <c>IdentityHashMap</c> class objects but is intentionally not
+      /// intended to provide <c>java.util.IdentityHashMap</c> semantics.
+      /// </summary>
+        [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class CacheableIdentityHashMap
+        : public CacheableHashMap
+      {
+      public:
+        /// <summary>
+        /// Allocates a new empty instance.
+        /// </summary>
+        inline CacheableIdentityHashMap()
+          : CacheableHashMap()
+        { }
+
+        /// <summary>
+        /// Allocates a new instance copying from the given dictionary.
+        /// </summary>
+        /// <param name="dictionary">
+        /// The dictionary whose elements are copied to this HashMap.
+        /// </param>
+        inline CacheableIdentityHashMap(System::Collections::Generic::IDictionary<
+          ICacheableKey^, IGFSerializable^>^ dictionary)
+          : CacheableHashMap(dictionary)
+        { }
+
+        /// <summary>
+        /// Allocates a new empty instance with given initial size.
+        /// </summary>
+        /// <param name="capacity">
+        /// The initial capacity of the HashMap.
+        /// </param>
+        inline CacheableIdentityHashMap(int32_t capacity)
+          : CacheableHashMap(capacity)
+        { }
+
+        /// <summary>
+        /// Static function to create a new empty instance.
+        /// </summary>
+        inline static CacheableIdentityHashMap^ Create()
+        {
+          return gcnew CacheableIdentityHashMap();
+        }
+
+        /// <summary>
+        /// Static function to create a new instance copying from the
+        /// given dictionary.
+        /// </summary>
+        inline static CacheableIdentityHashMap^ Create(
+          System::Collections::Generic::IDictionary<ICacheableKey^, IGFSerializable^>^ dictionary)
+        {
+          return gcnew CacheableIdentityHashMap(dictionary);
+        }
+
+        /// <summary>
+        /// Static function to create a new instance with given initial size.
+        /// </summary>
+        inline static CacheableIdentityHashMap^ Create(int32_t capacity)
+        {
+          return gcnew CacheableIdentityHashMap(capacity);
+        }
+
+        // Region: IGFSerializable Members
+
+        /// <summary>
+        /// Returns the classId of the instance being serialized.
+        /// This is used by deserialization to determine what instance
+        /// type to create and deserialize into.
+        /// </summary>
+        /// <returns>the classId</returns>
+        virtual property uint32_t ClassId
+        {
+          virtual uint32_t get() override
+          {
+            return GemFireClassIds::CacheableIdentityHashMap;
+          }
+        }
+
+        // End Region: IGFSerializable Members
+
+        /// <summary>
+        /// Factory function to register this class.
+        /// </summary>
+        static IGFSerializable^ CreateDeserializable()
+        {
+          return gcnew CacheableIdentityHashMap();
+        }
+      };
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/CacheableKeyM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/CacheableKeyM.cpp b/geode-client-native/src/clicache/CacheableKeyM.cpp
new file mode 100644
index 0000000..28c4a8a
--- /dev/null
+++ b/geode-client-native/src/clicache/CacheableKeyM.cpp
@@ -0,0 +1,98 @@
+/*=========================================================================
+ * 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 "gf_includes.hpp"
+#include "SerializableM.hpp"
+#include "CacheableKeyM.hpp"
+#include "CacheableStringM.hpp"
+#include "LogM.hpp"
+#include "CacheableBuiltinsM.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    { 
+      int32_t GemStone::GemFire::Cache::CacheableKey::GetHashCode()
+      {
+        return static_cast<gemfire::CacheableKey*>(NativePtr())->hashcode();
+      }
+
+      bool GemStone::GemFire::Cache::CacheableKey::Equals(GemStone::GemFire::Cache::ICacheableKey^ other)
+      {
+        if (other == nullptr || other->ClassId != ClassId) {
+          return false;
+        }
+        return static_cast<gemfire::CacheableKey*>(NativePtr())->operator==(
+          *static_cast<gemfire::CacheableKey*>(
+            ((GemStone::GemFire::Cache::CacheableKey^)other)->NativePtr()));
+      }
+
+      bool GemStone::GemFire::Cache::CacheableKey::Equals(Object^ obj)
+      {
+        GemStone::GemFire::Cache::CacheableKey^ otherKey =
+          dynamic_cast<GemStone::GemFire::Cache::CacheableKey^>(obj);
+
+        if (otherKey != nullptr) {
+          return static_cast<gemfire::CacheableKey*>(NativePtr())->operator==(
+            *static_cast<gemfire::CacheableKey*>(otherKey->NativePtr()));
+        }
+        return false;
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (Byte value)
+      {
+        return GemStone::GemFire::Cache::CacheableByte::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (bool value)
+      {
+        return GemStone::GemFire::Cache::CacheableBoolean::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (Char value)
+      {
+        return GemStone::GemFire::Cache::CacheableCharacter::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (Double value)
+      {
+        return GemStone::GemFire::Cache::CacheableDouble::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (Single value)
+      {
+        return GemStone::GemFire::Cache::CacheableFloat::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (int16_t value)
+      {
+        return GemStone::GemFire::Cache::CacheableInt16::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (int32_t value)
+      {
+        return GemStone::GemFire::Cache::CacheableInt32::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (int64_t value)
+      {
+        return GemStone::GemFire::Cache::CacheableInt64::Create(value);
+      }
+
+      GemStone::GemFire::Cache::CacheableKey::operator GemStone::GemFire::Cache::CacheableKey^ (String^ value)
+      {
+        return GemStone::GemFire::Cache::CacheableString::Create(value);
+      }
+    }
+  }
+}


Mime
View raw message