geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject [06/51] [partial] geode git commit: Software Grant Agreement (SGA) from Pivotal for Apache Geode
Date Fri, 13 Jan 2017 22:45:50 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/Execution.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Execution.hpp b/src/clicache/src/Execution.hpp
new file mode 100644
index 0000000..2175fce
--- /dev/null
+++ b/src/clicache/src/Execution.hpp
@@ -0,0 +1,102 @@
+/*=========================================================================
+ * 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 <gfcpp/Execution.hpp>
+#include "impl/NativeWrapper.hpp"
+//#include "impl/ResultCollectorProxy.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache {
+      //interface class IGFSerializable;
+      namespace Generic
+    {
+      generic<class TResult>
+      interface class IResultCollector;
+
+      generic<class TResult>
+      ref class ResultCollector;
+
+      /// <summary>
+      /// This class encapsulates events that occur for cq.
+      /// </summary>
+      generic<class TResult>
+      public ref class Execution sealed
+        : public Internal::SBWrap<gemfire::Execution>
+      {
+      public:
+        /// <summary>
+		/// Add a routing object, 
+        /// Return self.
+        /// </summary>
+		generic<class TFilter>
+    Execution<TResult>^ WithFilter(System::Collections::Generic::ICollection<TFilter>^ routingObj);
+
+        /// <summary>
+		/// Add an argument, 
+        /// Return self.
+        /// </summary>
+    generic<class TArgs>
+		Execution<TResult>^ WithArgs(TArgs args);
+
+        /// <summary>
+		/// Add a result collector, 
+        /// Return self.
+        /// </summary>
+		Execution<TResult>^ WithCollector(IResultCollector<TResult>^ rc);
+
+        /// <summary>
+        /// Execute a function, 
+        /// Return resultCollector.
+        /// </summary>
+		/// <param name="timeout"> Value to wait for the operation to finish before timing out.</param> 
+        IResultCollector<TResult>^ Execute(String^ func, UInt32 timeout);
+
+        /// <summary>
+        /// Execute a function, 
+        /// Return resultCollector.
+        /// </summary>
+        IResultCollector<TResult>^ Execute(String^ func);
+
+      internal:
+
+        /// <summary>
+        /// Internal factory function to wrap a native object pointer inside
+        /// this managed class with null pointer check.
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        /// <returns>
+        /// The managed wrapper object; null if the native pointer is null.
+        /// </returns>
+        inline static Execution<TResult>^ Create( gemfire::Execution* nativeptr, IResultCollector<TResult>^ rc )
+        {
+          return ( nativeptr != nullptr ?
+            gcnew Execution<TResult>( nativeptr, rc ) : nullptr );
+	}
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer.
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline Execution( gemfire::Execution* nativeptr, IResultCollector<TResult>^ rc )
+          : SBWrap( nativeptr ) { m_rc = rc;}
+      private:
+        IResultCollector<TResult>^ m_rc;
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ExpirationAction.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ExpirationAction.hpp b/src/clicache/src/ExpirationAction.hpp
new file mode 100644
index 0000000..e32f9de
--- /dev/null
+++ b/src/clicache/src/ExpirationAction.hpp
@@ -0,0 +1,127 @@
+/*=========================================================================
+ * 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 <gfcpp/ExpirationAction.hpp>
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      /// <summary>
+      /// Enumerated type for expiration (LRU) actions.
+      /// Contains values for setting an action type.
+      /// </summary>
+      public enum class ExpirationAction
+      {
+        /// <summary>
+        /// When the region or cached object expires, it is invalidated.
+        /// </summary>
+        Invalidate = 0,
+
+        /// <summary>
+        /// When expired, invalidated locally only.
+        /// </summary>
+        LocalInvalidate,
+
+        /// <summary>
+        /// When the region or cached object expires, it is destroyed.
+        /// </summary>
+        Destroy,
+
+        /// <summary>
+        /// When expired, destroyed locally only.
+        /// </summary>
+        LocalDestroy,
+
+        /// <summary>Invalid action type.</summary>
+        InvalidAction
+      };
+
+
+      /// <summary>
+      /// Static class containing convenience methods for <c>ExpirationAction</c>.
+      /// </summary>
+      public ref class Expiration STATICCLASS
+      {
+      public:
+
+        /// <summary>
+        /// Returns true if this action is distributed invalidate.
+        /// </summary>
+        /// <returns>true if this an <c>Invalidate</c></returns>
+        inline static bool IsInvalidate( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Invalidate);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local invalidate.
+        /// </summary>
+        /// <returns>true if this is a <c>LocalInvalidate</c></returns>
+        inline static bool IsLocalInvalidate( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::LocalInvalidate);
+        }
+
+        /// <summary>
+        /// Returns true if this action is distributed destroy.
+        /// </summary>
+        /// <returns>true if this is <c>Destroy</c></returns>
+        inline static bool IsDestroy( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Destroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local destroy.
+        /// </summary>
+        /// <returns>true if this is <c>LocalDestroy</c></returns>
+        inline static bool IsLocalDestroy( ExpirationAction type )
+        {
+          return (type == ExpirationAction::LocalDestroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is local.
+        /// </summary>
+        /// <returns>true if this is <c>LocalInvalidate</c> or
+        /// <c>LocalDestroy</c></returns>
+        inline static bool IsLocal( ExpirationAction type )
+        {
+          return (type == ExpirationAction::LocalInvalidate) ||
+            (type == ExpirationAction::LocalDestroy);
+        }
+
+        /// <summary>
+        /// Returns true if this action is distributed.
+        /// </summary>
+        /// <returns>true if this is an <c>Invalidate</c> or
+        /// a <c>Destroy</c></returns>
+        inline static bool IsDistributed( ExpirationAction type ) 
+        {
+          return (type == ExpirationAction::Invalidate) ||
+            (type == ExpirationAction::Destroy);
+        }
+      };
+
+    }
+  }
+}
+ } //namespace 
+

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/FunctionService.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/FunctionService.cpp b/src/clicache/src/FunctionService.cpp
new file mode 100644
index 0000000..f7714ba
--- /dev/null
+++ b/src/clicache/src/FunctionService.cpp
@@ -0,0 +1,132 @@
+/*=========================================================================
+ * 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 "FunctionService.hpp"
+#include "Pool.hpp"
+#include "Region.hpp"
+#include "Execution.hpp"
+#include <gfcpp/RegionService.hpp>
+#include "impl/AuthenticatedCache.hpp"
+#include "impl/SafeConvert.hpp"
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      generic <class TResult>
+      generic <class TKey, class TValue>
+      Execution<TResult>^ FunctionService<TResult>::OnRegion( IRegion<TKey, TValue>^ rg )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+          
+          IRegion<TKey, TValue>^ regImpl = safe_cast<IRegion<TKey, TValue>^>( rg);
+
+        gemfire::RegionPtr regionptr(GetNativePtrFromSBWrapGeneric((Generic::Region<TKey, TValue>^)regImpl));
+
+          gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onRegion(
+            regionptr ) );
+          return Execution<TResult>::Create( nativeptr.ptr( ), nullptr );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic <class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServer( Pool/*<TKey, TValue>*/^ pl )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          gemfire::PoolPtr poolptr(GetNativePtrFromSBWrapGeneric<gemfire::Pool>( pl ) );
+
+          gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServer(
+            poolptr ) );
+          return Execution<TResult>::Create( nativeptr.ptr( ) , nullptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+      
+      generic <class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServers( Pool/*<TKey, TValue>*/^ pl )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          gemfire::PoolPtr poolptr(GetNativePtrFromSBWrapGeneric<gemfire::Pool>( pl ) );
+          gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServers(
+            poolptr ) );
+          return Execution<TResult>::Create( nativeptr.ptr( ) , nullptr);
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServer( IRegionService^ cache )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          GemStone::GemFire::Cache::Generic::Cache^ realCache =
+            dynamic_cast<GemStone::GemFire::Cache::Generic::Cache^>(cache);
+
+        if(realCache != nullptr)
+        {
+            gemfire::RegionServicePtr cacheptr(GetNativePtr<gemfire::RegionService>( realCache ) );
+
+            gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServer(
+              cacheptr ) );
+            return Execution<TResult>::Create( nativeptr.ptr( ), nullptr );
+        }
+        else
+        {
+          GemStone::GemFire::Cache::Generic::AuthenticatedCache^ authCache =
+            dynamic_cast<GemStone::GemFire::Cache::Generic::AuthenticatedCache^>(cache);
+          gemfire::RegionServicePtr cacheptr(GetNativePtr<gemfire::RegionService>( authCache ) );
+
+            gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServer(
+              cacheptr ) );
+            return Execution<TResult>::Create( nativeptr.ptr( ), nullptr );
+        }
+
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+
+      generic<class TResult>
+      Execution<TResult>^ FunctionService<TResult>::OnServers( IRegionService^ cache )
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          GemStone::GemFire::Cache::Generic::Cache^ realCache =
+          dynamic_cast<GemStone::GemFire::Cache::Generic::Cache^>(cache);
+
+          if(realCache != nullptr)
+          {
+            gemfire::RegionServicePtr cacheptr(GetNativePtr<gemfire::RegionService>( realCache ) );
+
+            gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServers(
+              cacheptr ) );
+            return Execution<TResult>::Create( nativeptr.ptr( ), nullptr );
+          }
+          else
+          {
+            GemStone::GemFire::Cache::Generic::AuthenticatedCache^ authCache =
+              dynamic_cast<GemStone::GemFire::Cache::Generic::AuthenticatedCache^>(cache);
+            gemfire::RegionServicePtr cacheptr(GetNativePtr<gemfire::RegionService>( authCache ) );
+
+            gemfire::ExecutionPtr& nativeptr( gemfire::FunctionService::onServers(
+              cacheptr ) );
+            return Execution<TResult>::Create( nativeptr.ptr( ) , nullptr);
+          }
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/FunctionService.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/FunctionService.hpp b/src/clicache/src/FunctionService.hpp
new file mode 100644
index 0000000..741027a
--- /dev/null
+++ b/src/clicache/src/FunctionService.hpp
@@ -0,0 +1,100 @@
+/*=========================================================================
+ * 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 <gfcpp/FunctionService.hpp>
+#include "Cache.hpp"
+//#include "impl/NativeWrapper.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+    //  generic<class TKey, class TValue>
+      ref class Pool;
+     
+      generic<class TResult>
+      ref class Execution;
+
+      /// <summary>
+      /// A factory class used to create Execute object for function execution
+      /// </summary>
+      /// <remarks>
+      generic<class TResult>
+      public ref class FunctionService 
+        : public Internal::SBWrap<gemfire::FunctionService>
+      {
+      public:
+
+        /// <summary>
+        /// Creates a new region Execution object
+        /// </summary>
+        /// <remarks>
+        /// If Pool is multiusersecure mode then one need to pass logical instance of Region Pool->CreateSecureUserCache(<credentials>)->getRegion(<regionPath>).
+        /// </remarks>
+        generic <class TKey, class TValue>
+        static Execution<TResult>^ OnRegion( IRegion<TKey, TValue>^ rg );
+
+        /// <summary>
+        /// Creates a new Execution object on one server
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="UnsupportedOperationException">unsupported operation exception, when Pool is in multiusersecure mode.</exception>
+        //generic<class TKey, class TValue>
+        static Execution<TResult>^ OnServer( Pool/*<TKey, TValue>*/^ pl );
+
+        /// <summary>
+        /// Creates a new Execution object on all servers in the pool
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="UnsupportedOperationException">unsupported operation exception, when Pool is in multiusersecure mode.</exception>
+        //generic<class TKey, class TValue>
+        static Execution<TResult>^ OnServers( Pool/*<TKey, TValue>*/^ pl );
+
+        /// <summary>
+        /// Creates a new Execution object on one server.
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="IllegalStateException">when Pool has been closed.</exception>
+        //generic<class TResult>
+        static Execution<TResult>^ OnServer( IRegionService^ cache );
+
+        /// <summary>
+        /// Creates a new Execution object on all servers in the pool.
+        /// </summary>
+        /// <remarks>
+        /// </remarks>
+        /// <exception cref="IllegalStateException">when Pool has been closed.</exception>
+        //generic<class TResult>
+        static Execution<TResult>^ OnServers( IRegionService^ cache );
+        
+      internal:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline FunctionService( gemfire::FunctionService* nativeptr )
+          : SBWrap( nativeptr ) { }
+
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/GemFireClassIds.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/GemFireClassIds.hpp b/src/clicache/src/GemFireClassIds.hpp
new file mode 100644
index 0000000..a960e40
--- /dev/null
+++ b/src/clicache/src/GemFireClassIds.hpp
@@ -0,0 +1,361 @@
+/*=========================================================================
+ * 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 <gfcpp/GemfireTypeIds.hpp>
+
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+			struct PdxTypes
+      {
+				enum PdxTypesInternal
+				{
+					BOOLEAN,
+					BYTE,
+					CHAR,
+					SHORT,
+					INT,
+					LONG,
+					FLOAT,
+					DOUBLE,
+					DATE,
+					STRING,
+					OBJECT,
+					BOOLEAN_ARRAY,
+					CHAR_ARRAY,
+					BYTE_ARRAY,
+					SHORT_ARRAY,
+					INT_ARRAY,
+					LONG_ARRAY,
+					FLOAT_ARRAY,
+					DOUBLE_ARRAY,
+					STRING_ARRAY,
+					OBJECT_ARRAY,
+					ARRAY_OF_BYTE_ARRAYS
+				};
+      };
+
+      /// <summary>
+      /// Static class containing the classIds of the built-in cacheable types.
+      /// </summary>
+      public ref class GemFireClassIds
+      {
+      public:
+
+        /// <summary>
+        /// ClassId of <c>Properties</c> class
+        /// </summary>
+        literal uint32_t Properties =
+          gemfire::GemfireTypeIds::Properties + 0x80000000;
+
+        /// <summary>        
+        /// ClassId of <c>CharArray</c> class
+        /// </summary>
+        literal uint32_t CharArray =
+          gemfire::GemfireTypeIds::CharArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>BooleanArray</c> class
+        /// </summary>
+        literal uint32_t BooleanArray =
+          gemfire::GemfireTypeIds::BooleanArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>RegionAttributes</c> class
+        /// </summary>
+        literal uint32_t RegionAttributes =
+          gemfire::GemfireTypeIds::RegionAttributes + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableUndefined</c> class
+        /// Implementation note: this has DSFID of FixedIDByte hence a
+        /// different increment.
+        /// </summary>
+        literal uint32_t CacheableUndefined =
+          gemfire::GemfireTypeIds::CacheableUndefined + 0xa0000000;
+
+        literal uint32_t EnumInfo =
+          gemfire::GemfireTypeIds::EnumInfo + 0xa0000000;
+
+        /// <summary>
+        /// ClassId of <c>Struct</c> class
+        /// </summary>
+        literal uint32_t Struct =
+          gemfire::GemfireTypeIds::Struct + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class
+        /// </summary>
+        literal uint32_t CacheableString =
+          gemfire::GemfireTypeIds::CacheableString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for huge strings
+        /// </summary>
+        literal uint32_t CacheableStringHuge =
+          gemfire::GemfireTypeIds::CacheableStringHuge + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableBytes</c> class
+        /// </summary>
+        literal uint32_t CacheableBytes =
+          gemfire::GemfireTypeIds::CacheableBytes + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16Array</c> class
+        /// </summary>
+        literal uint32_t CacheableInt16Array =
+          gemfire::GemfireTypeIds::CacheableInt16Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt32Array</c> class
+        /// </summary>
+        literal uint32_t CacheableInt32Array =
+          gemfire::GemfireTypeIds::CacheableInt32Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt64Array</c> class
+        /// </summary>
+        literal uint32_t CacheableInt64Array =
+          gemfire::GemfireTypeIds::CacheableInt64Array + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFloatArray</c> class
+        /// </summary>
+        literal uint32_t CacheableFloatArray =
+          gemfire::GemfireTypeIds::CacheableFloatArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDoubleArray</c> class
+        /// </summary>
+        literal uint32_t CacheableDoubleArray =
+          gemfire::GemfireTypeIds::CacheableDoubleArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableVector</c> class for object arrays
+        /// </summary>
+        literal uint32_t CacheableObjectArray =
+          gemfire::GemfireTypeIds::CacheableObjectArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableBoolean</c> class
+        /// </summary>
+        literal uint32_t CacheableBoolean =
+          gemfire::GemfireTypeIds::CacheableBoolean + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16</c> class for wide-characters
+        /// </summary>
+        literal uint32_t CacheableCharacter =
+          gemfire::GemfireTypeIds::CacheableWideChar + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableByte</c> class
+        /// </summary>
+        literal uint32_t CacheableByte =
+          gemfire::GemfireTypeIds::CacheableByte + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt16</c> class
+        /// </summary>
+        literal uint32_t CacheableInt16 =
+          gemfire::GemfireTypeIds::CacheableInt16 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt32</c> class
+        /// </summary>
+        literal uint32_t CacheableInt32 =
+          gemfire::GemfireTypeIds::CacheableInt32 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableInt64</c> class
+        /// </summary>
+        literal uint32_t CacheableInt64 =
+          gemfire::GemfireTypeIds::CacheableInt64 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFloat</c> class
+        /// </summary>
+        literal uint32_t CacheableFloat =
+          gemfire::GemfireTypeIds::CacheableFloat + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDouble</c> class
+        /// </summary>
+        literal uint32_t CacheableDouble =
+          gemfire::GemfireTypeIds::CacheableDouble + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableDate</c> class
+        /// </summary>
+        literal uint32_t CacheableDate =
+          gemfire::GemfireTypeIds::CacheableDate + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableFileName</c> class
+        /// </summary>
+        literal uint32_t CacheableFileName =
+          gemfire::GemfireTypeIds::CacheableFileName + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableStringArray</c> class
+        /// </summary>
+        literal uint32_t CacheableStringArray =
+          gemfire::GemfireTypeIds::CacheableStringArray + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableVector</c> class
+        /// </summary>
+        literal uint32_t CacheableVector =
+          gemfire::GemfireTypeIds::CacheableVector + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableStack</c> class
+        /// </summary>
+        literal uint32_t CacheableStack =
+          gemfire::GemfireTypeIds::CacheableStack + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableArrayList</c> class
+        /// </summary>
+        literal uint32_t CacheableArrayList =
+          gemfire::GemfireTypeIds::CacheableArrayList + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableArrayList</c> class
+        /// </summary>
+        literal uint32_t CacheableLinkedList =
+          gemfire::GemfireTypeIds::CacheableLinkedList + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashSet</c> class
+        /// </summary>
+        literal uint32_t CacheableHashSet =
+          gemfire::GemfireTypeIds::CacheableHashSet + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableLinkedHashSet</c> class
+        /// </summary>
+        literal uint32_t CacheableLinkedHashSet =
+          gemfire::GemfireTypeIds::CacheableLinkedHashSet + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashMap</c> class
+        /// </summary>
+        literal uint32_t CacheableHashMap =
+          gemfire::GemfireTypeIds::CacheableHashMap + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableHashTable</c> class
+        /// </summary>
+        literal uint32_t CacheableHashTable =
+          gemfire::GemfireTypeIds::CacheableHashTable + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableIdentityHashMap</c> class
+        /// </summary>
+        literal uint32_t CacheableIdentityHashMap =
+          gemfire::GemfireTypeIds::CacheableIdentityHashMap + 0x80000000;
+
+        /// <summary>
+        /// Not used.
+        /// </summary>
+        literal uint32_t CacheableTimeUnit =
+          gemfire::GemfireTypeIds::CacheableTimeUnit + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for null strings
+        /// </summary>
+        literal uint32_t CacheableNullString =
+          gemfire::GemfireTypeIds::CacheableNullString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for ASCII strings
+        /// </summary>
+        literal uint32_t CacheableASCIIString =
+          gemfire::GemfireTypeIds::CacheableASCIIString + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableString</c> class for huge ASCII strings
+        /// </summary>
+        literal uint32_t CacheableASCIIStringHuge =
+          gemfire::GemfireTypeIds::CacheableASCIIStringHuge + 0x80000000;
+
+
+        // Built-in managed types.
+
+        /// <summary>
+        /// ClassId of <c>CacheableObject</c> class
+        /// </summary>
+        literal uint32_t CacheableManagedObject = 7 + 0x80000000;
+
+        /// <summary>
+        /// ClassId of <c>CacheableObjectXml</c> class
+        /// </summary>
+        literal uint32_t CacheableManagedObjectXml = 8 + 0x80000000;
+				   internal:
+
+        literal uint32_t PdxType = gemfire::GemfireTypeIds::PdxType + 0x80000000;
+
+        literal uint32_t DATA_SERIALIZABLE = 45;
+        literal uint32_t JAVA_CLASS = 43;
+
+        //internal gemfire typeids..
+      /*  literal Byte USERCLASS = 40;
+        literal Byte USERMAP = 94;
+        literal Byte USERCOLLECTION = 95;
+        literal Byte ARRAYOFBYTEARRAYS = 91;
+        literal Byte GEMFIREREGION =  98;
+
+        literal Byte BOOLEAN_TYPE = 17;
+        literal Byte CHARACTER_TYPE = 18;
+        literal Byte BYTE_TYPE = 19;
+        literal Byte SHORT_TYPE = 20;
+        literal Byte INTEGER_TYPE = 21;
+        literal Byte LONG_TYPE = 22;
+        literal Byte FLOAT_TYPE = 23;
+        literal Byte DOUBLE_TYPE = 24;
+        literal Byte VOID_TYPE = 25;   */  
+
+        literal Byte PDX = 93;
+        literal Byte PDX_ENUM = 94;
+
+        literal Byte BYTE_SIZE = 1;
+  
+        literal Byte BOOLEAN_SIZE = 1;
+  
+        literal Byte CHAR_SIZE = 2;
+
+        literal Byte SHORT_SIZE = 2;
+  
+        literal Byte INTEGER_SIZE = 4;
+  
+        literal Byte FLOAT_SIZE = 4;
+  
+        literal Byte LONG_SIZE = 8;
+  
+        literal Byte DOUBLE_SIZE = 8;
+  
+        literal Byte DATE_SIZE = 8;
+      };
+
+    }
+  }
+}
+ } //namespace 
+

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/IAuthInitialize.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/IAuthInitialize.hpp b/src/clicache/src/IAuthInitialize.hpp
new file mode 100644
index 0000000..967ede7
--- /dev/null
+++ b/src/clicache/src/IAuthInitialize.hpp
@@ -0,0 +1,75 @@
+/*=========================================================================
+ * 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 "Properties.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache {
+    
+    namespace Generic
+    {
+      /// <summary>
+      /// Specifies the mechanism to obtain credentials for a client.
+      /// It is mandantory for clients when the server is running in secure
+      /// mode having a <c>security-client-authenticator</c> module specified.
+      /// Implementations should register the library path as
+      /// <c>security-client-auth-library</c> system property and factory
+      /// function (a zero argument function returning pointer to an
+      /// AuthInitialize object) as the <c>security-client-auth-factory</c>
+      /// system property.
+      ///
+      /// For a managed class implementing <c>IAuthInitialize</c> the fully
+      /// qualified name of the factory function should be provided in the
+      /// form {Namespace}.{Class Name}.{Method Name} as the
+      /// <c>security-client-auth-factory</c> property.
+      /// </summary>
+      public interface class IAuthInitialize
+      {
+      public:
+
+        /// <summary>
+        /// Initialize with the given set of security properties
+        /// return the credentials for the client as properties.
+        /// </summary>
+        /// <param name="props">
+        /// the set of <c>security-*</c> properties provided to the
+        /// <see cref="DistributedSystem.connect"/> method
+        /// </param>
+        /// <param name="server">
+        /// the ID of the current endpoint in the format "host:port"
+        /// </param>
+        /// <returns>
+        /// the credentials to be used for the given server
+        /// </returns>
+        /// <remarks>
+        /// This method can modify the given set of properties. For
+        /// example it may invoke external agents or even interact with
+        /// the user.
+        /// </remarks>
+        //generic <class TPropKey, class TPropValue>
+        Properties<String^, Object^>^ GetCredentials(Properties<String^, String^>^ props, String^ server);
+
+        /// <summary>
+        /// Invoked before the cache goes down.
+        /// </summary>
+        void Close();
+
+      };
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICacheListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICacheListener.hpp b/src/clicache/src/ICacheListener.hpp
new file mode 100644
index 0000000..1eadb17
--- /dev/null
+++ b/src/clicache/src/ICacheListener.hpp
@@ -0,0 +1,201 @@
+/*=========================================================================
+ * 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 "IRegion.hpp"
+//#include "Region.hpp"
+
+#include "EntryEvent.hpp"
+#include "RegionEvent.hpp"
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// </summary>
+      /// <remarks>
+      /// Listeners are change notifications that are invoked
+      /// AFTER the change has occured for region update operations on a client.
+      /// Listeners also receive notifications when entries in a region are modified.
+      /// Multiple events can cause concurrent invocation
+      /// of <c>ICacheListener</c> methods.  If event A occurs before event B,
+      /// there is no guarantee that their corresponding <c>ICacheListener</c>
+      /// method invocations will occur in the same order. Any exceptions thrown by
+      /// the listener are caught by GemFire and logged. If the exception is due to
+      /// listener invocation on the same thread where a region operation has been
+      /// performed, then a <c>CacheListenerException</c> is thrown back to
+      /// the application. If the exception is for a notification received from
+      /// server then that is logged and the notification thread moves on to
+      /// receiving other notifications.
+      /// <para>
+      /// A cache listener is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      ///
+      /// There are two cases in which listeners are invoked. The first is when a
+      /// region modification operation (e.g. put, create, destroy, invalidate)
+      /// is performed. For this case it is important to ensure that minimal work is
+      /// done in the listener before returning control back to Gemfire since the
+      /// operation will block till the listener has not completed. For example,
+      /// a listener implementation may choose to hand off the event to a thread pool
+      /// that then processes the event on its thread rather than the listener thread.
+      /// The second is when notifications are received from java server as a result
+      /// of region register interest calls (<c>Region.RegisterKeys</c> etc),
+      /// or invalidate notifications when notify-by-subscription is false on the
+      /// server. In this case the methods of <c>ICacheListener</c> are invoked
+      /// asynchronously (i.e. does not block the thread that receives notification
+      /// messages). Additionally for the latter case of notifications from server,
+      /// listener is always invoked whether or not local operation is successful
+      /// e.g. if a destroy notification is received and key does not exist in the
+      /// region, the listener will still be invoked. This is different from the
+      /// first case where listeners are invoked only when the region update
+      /// operation succeeds.
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheListener" />
+      /// <seealso cref="RegionAttributes.CacheListener" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheWriter" />
+      /// <seealso cref="CacheListenerException" />
+      generic<class TKey, class TValue>
+      public interface class ICacheListener
+      {
+      public:
+
+        /// <summary>
+        /// Handles the event of a new key being added to a region.
+        /// </summary>
+        /// <remarks>
+        /// The entry did not previously exist in this region in the local cache
+        /// (even with a null value).
+        /// <para>
+        /// This function does not throw any exception.
+        /// </para>
+        /// </remarks>
+        /// <param name="ev">
+        /// Denotes the event object associated with the entry creation.
+        /// </param>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        void AfterCreate( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of an entry's value being modified in a region.
+        /// </summary>
+        /// <remarks>
+        /// This entry previously existed in this region in the local cache,
+        /// but its previous value may have been null.
+        /// </remarks>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with updating the entry.
+        /// </param>
+        /// <seealso cref="Region.Put" />
+        void AfterUpdate( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of an entry's value being invalidated.
+        /// </summary>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with the entry invalidation.
+        /// </param>
+        void AfterInvalidate( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of an entry being destroyed.
+        /// </summary>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with the entry destruction.
+        /// </param>
+        /// <seealso cref="Region.Destroy" />
+        void AfterDestroy( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of a region being cleared.
+        /// </summary>
+        void AfterRegionClear( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of a region being invalidated.
+        /// </summary>
+        /// <remarks>
+        /// Events are not invoked for each individual value that is invalidated
+        /// as a result of the region being invalidated. Each subregion, however,
+        /// gets its own <c>RegionInvalidated</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region invalidation.
+        /// </param>
+        /// <seealso cref="Region.InvalidateRegion" />
+        void AfterRegionInvalidate( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of a region being destroyed.
+        /// </summary>
+        /// <remarks>
+        /// Events are not invoked for each individual entry that is destroyed
+        /// as a result of the region being destroyed. Each subregion, however,
+        /// gets its own <c>AfterRegionDestroyed</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region destruction.
+        /// </param>
+        /// <seealso cref="Region.DestroyRegion" />
+        void AfterRegionDestroy( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Handles the event of a region going live.
+        /// </summary>
+        /// <remarks>
+        /// Each subregion gets its own <c>AfterRegionLive</c> event invoked on its listener.
+        /// </remarks>
+        /// <param name="ev">
+        /// RegionEvent denotes the event object associated with the region going live.
+        /// </param>
+        /// <seealso cref="Cache.ReadyForEvents" />
+        void AfterRegionLive( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources,
+        /// such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// </remarks>
+        /// <param>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </param>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close( IRegion<TKey, TValue>^ region );
+
+        ///<summary>
+        ///Called when all the endpoints associated with region are down.
+        ///This will be called when all the endpoints are down for the first time.
+        ///If endpoints come up and again go down it will be called again.
+        ///This will also be called when all endpoints are down and region is attached to the pool.
+        ///</summary>
+        ///<remarks>
+        ///</remark>
+        ///<param>
+        ///region Region^ denotes the assosiated region.
+        ///</param>
+        void AfterRegionDisconnected( IRegion<TKey, TValue>^ region );
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICacheLoader.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICacheLoader.hpp b/src/clicache/src/ICacheLoader.hpp
new file mode 100644
index 0000000..89a3852
--- /dev/null
+++ b/src/clicache/src/ICacheLoader.hpp
@@ -0,0 +1,107 @@
+/*=========================================================================
+ * 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 <gfcpp/CacheLoader.hpp>
+#include "IRegion.hpp"
+//#include "Region.hpp"
+//#include "ICacheableKey.hpp"
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache {
+      namespace Generic
+    {
+      //interface class ICacheableKey;
+
+      /// <summary>
+      /// CacheLoader
+      /// </summary>
+      /// <remarks>
+      /// CacheLoader
+      /// </remarks>
+      public ref class CacheLoader STATICCLASS
+      {
+      };
+
+      /// <summary>
+      /// A data-loading application plug-in that can be installed on a region.
+      /// </summary>
+      /// <remarks>
+      /// Loaders facilitate loading of data into the cache from a third-party data source. 
+      /// When an application does a
+      /// lookup for a key in a region and it does not exist, GemFire checks to
+      /// see if any loaders are available for the region in the system and
+      /// invokes them to get the value for the key into the cache.
+      /// <para>
+      /// A cache loader is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      /// When <see cref="Region.Get" /> is called for a region
+      /// entry that has a null value, the <see cref="ICacheLoader.Load" />
+      /// method of the region's cache loader is invoked.  The <c>Load</c> method
+      /// creates the value for the desired key by performing an operation such
+      /// as a database query. 
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheLoader" />
+      /// <seealso cref="RegionAttributes.CacheLoader" />
+      /// <seealso cref="ICacheListener" />
+      /// <seealso cref="ICacheWriter" />
+      generic<class TKey, class TValue>
+      public interface class ICacheLoader
+      {
+      public:
+
+        /// <summary>
+        /// Loads a value. Application writers should implement this
+        /// method to customize the loading of a value.
+        /// </summary>
+        /// <remarks>
+        /// This method is called
+        /// by the caching service when the requested value is not in the cache.
+        /// Any exception thrown by this method is propagated back to and thrown
+        /// by the invocation of <see cref="Region.Get" /> that triggered this load.
+        /// </remarks>
+        /// <param name="region">a Region for which this is called.</param>
+        /// <param name="key">the key for the cacheable</param>
+        /// <param name="callbackArgument">
+        /// </param>
+        /// <returns>
+        /// the value supplied for this key, or null if no value can be
+        /// supplied. 
+        /// If every available loader returns
+        /// a null value, <see cref="Region.Get" /> will return null.
+        /// </returns>
+        /// <seealso cref="Region.Get" />
+        TValue Load(IRegion<TKey, TValue>^ region, TKey key,
+          Object^ callbackArgument);
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources, such as
+        /// database connections. Any runtime exceptions this method throws will be logged.
+        /// <para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close( IRegion<TKey, TValue>^ region );
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICacheWriter.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICacheWriter.hpp b/src/clicache/src/ICacheWriter.hpp
new file mode 100644
index 0000000..bdfb6cc
--- /dev/null
+++ b/src/clicache/src/ICacheWriter.hpp
@@ -0,0 +1,163 @@
+/*=========================================================================
+ * 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 "IRegion.hpp"
+//#include "Region.hpp"
+
+#include "EntryEvent.hpp"
+#include "RegionEvent.hpp"
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// Defines methods that are called <b>before</b> entry modification,
+      /// such as writing the value to a database.
+      /// </summary>
+      /// <remarks>
+      /// <para>
+      /// A distributed region will typically have a single cache writer.
+      /// If the application is designed such that all or most updates to
+      /// a region occur on a node, the cache writer for the region should
+      /// be installed at that node. 
+      /// </para><para>
+      /// A cache writer is defined in the <see cref="RegionAttributes" />.
+      /// </para><para>
+      /// Cache writer invocations are initiated by the node where the entry or
+      /// region modification occurs. 
+      /// </para><para>
+      /// Before a region is updated via a put, create, or destroy operation,
+      /// GemFire will call an <c>ICacheWriter</c> that is installed anywhere in any
+      /// participating cache for that region, preferring a local <c>ICacheWriter</c>
+      /// if there is one. Usually there will be only one <c>ICacheWriter</c> in
+      /// the distributed system. If there are multiple <c>ICacheWriter</c>s
+      /// available in the distributed system, the GemFire
+      /// implementation always prefers one that is stored locally, or else picks one
+      /// arbitrarily. In any case, only one <c>ICacheWriter</c> will be invoked.
+      /// </para><para>
+      /// The typical use for a <c>ICacheWriter</c> is to update a database.
+      /// Application writers should implement these methods to execute
+      /// application-specific behavior before the cache is modified.
+      /// </para>
+      /// <para>
+      /// Note that cache writer callbacks are synchronous callbacks and have the ability
+      /// to veto the cache update. Since cache writer invocations require communications
+      /// over the network, (especially if they are not co-located on the nodes where the
+      /// change occurs) the use of cache writers presents a performance penalty.
+      /// </para><para>
+      /// The <c>ICacheWriter</c> is capable of aborting the update to the cache by throwing
+      /// a <c>CacheWriterException</c>. This exception or any runtime exception
+      /// thrown by the <c>ICacheWriter</c> will abort the operation, and the
+      /// exception will be propagated to the initiator of the operation, regardless
+      /// of whether the initiator is in the same process as the <c>ICacheWriter</c>.
+      /// </para>
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheWriter" />
+      /// <seealso cref="RegionAttributes.CacheWriter" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheListener" />
+      generic <class TKey, class TValue>
+      public interface class ICacheWriter
+      {
+      public:
+
+        /// <summary>
+        /// Called before an entry is updated. The entry update is initiated by a
+        /// <c>Put</c> or a <c>Get</c> that causes the loader to update an existing entry.
+        /// </summary>
+        /// <remarks>
+        /// The entry previously existed in the cache where the operation was
+        /// initiated, although the old value may have been null. The entry being
+        /// updated may or may not exist in the local cache where the CacheWriter is
+        /// installed.
+        /// </remarks>
+        /// <param name="ev">
+        /// event object associated with updating the entry
+        /// </param>
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        bool BeforeUpdate( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called before an entry is created. Entry creation is initiated by a
+        /// <c>Create</c>, a <c>Put</c>, or a <c>Get</c>.
+        /// </summary>
+        /// <remarks>
+        /// The <c>CacheWriter</c> can determine whether this value comes from a
+        /// <c>Get</c> or not from <c>Load</c>. The entry being
+        /// created may already exist in the local cache where this <c>CacheWriter</c>
+        /// is installed, but it does not yet exist in the cache where the operation was initiated.
+        /// </remarks>
+        /// <param name="ev">
+        /// event object associated with creating the entry
+        /// </param>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        bool BeforeCreate( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called before an entry is destroyed.
+        /// </summary>
+        /// <remarks>
+        /// The entry being destroyed may or may
+        /// not exist in the local cache where the CacheWriter is installed. This method
+        /// is <em>not</em> called as a result of expiration or
+        /// <see cref="Region.LocalDestroyRegion" />.
+        /// </remarks>
+        /// <param name="ev">
+        /// event object associated with destroying the entry
+        /// </param>
+        /// <seealso cref="Region.Destroy" />
+        bool BeforeDestroy( EntryEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called before this region is cleared.
+        /// </summary>
+        bool BeforeRegionClear( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called before this region is destroyed.
+        /// </summary>
+        /// <param name="ev">
+        /// event object associated with destroying the region
+        /// </param>
+        /// <seealso cref="Region.DestroyRegion" />
+        bool BeforeRegionDestroy( RegionEvent<TKey, TValue>^ ev );
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Implementations should clean up any external
+        /// resources, such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// </para><para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <param name="region">region to close</param>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close( IRegion<TKey, TValue>^ region );
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICacheableKey.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICacheableKey.hpp b/src/clicache/src/ICacheableKey.hpp
new file mode 100644
index 0000000..da5d9be
--- /dev/null
+++ b/src/clicache/src/ICacheableKey.hpp
@@ -0,0 +1,60 @@
+/*=========================================================================
+ * 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"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      /// <summary>
+      /// This interface class is the superclass of all user objects 
+      /// in the cache that can be used as a key.
+      /// </summary>
+      /// <remarks>
+      /// If an implementation is required to act as a key in the cache, then
+      /// it must implement this interface and preferably override
+      /// <c>System.Object.ToString</c> to obtain proper string representation.
+      /// Note that this interface requires that the class overrides
+      /// <c>Object.GetHashCode</c>. Though this is not enforced, the default
+      /// implementation in <c>System.Object</c> is almost certainly incorrect
+      /// and will not work correctly.
+      /// </remarks>
+      public interface class ICacheableKey
+        : public IGFSerializable
+      {
+      public:
+
+        /// <summary>
+        /// Get the hash code for this object. This is used in the internal
+        /// hash tables and so must have a nice distribution pattern.
+        /// </summary>
+        /// <returns>
+        /// The hashcode for this object.
+        /// </returns>
+        int32_t GetHashCode( );
+
+        /// <summary>
+        /// Returns true if this <c>ICacheableKey</c> matches the other.
+        /// </summary>
+        bool Equals( ICacheableKey^ other );
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICqAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICqAttributes.hpp b/src/clicache/src/ICqAttributes.hpp
new file mode 100644
index 0000000..e1c5e26
--- /dev/null
+++ b/src/clicache/src/ICqAttributes.hpp
@@ -0,0 +1,108 @@
+/*=========================================================================
+ * 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"
+
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      interface class CqListener;
+
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// Listener change notifications are invoked <c>after</c>
+      /// the change has occured.
+      /// </summary>
+      /// <remarks>
+      /// Listeners receive notifications when entries in a region change or changes occur to the
+      /// region attributes themselves.
+      /// <para>
+      /// A cache listener is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      /// The methods on a <c>ICacheListener</c>
+      /// are invoked asynchronously. Multiple events can cause concurrent invocation
+      /// of <c>ICacheListener</c> methods.  If event A occurs before event B,
+      /// there is no guarantee that their corresponding <c>ICacheListener</c>
+      /// method invocations will occur in the same order.  Any exceptions thrown by
+      /// the listener are caught by GemFire and logged. 
+      ///
+      /// Listeners are user callbacks that
+      /// are invoked by GemFire. It is important to ensure that minimal work is done in the
+      /// listener before returning control back to GemFire. For example, a listener
+      /// implementation may choose to hand off the event to a thread pool that then processes
+      /// the event on its thread rather than the listener thread
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheListener" />
+      /// <seealso cref="RegionAttributes.CacheListener" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheWriter" />
+      public interface class ICqListener
+      {
+      public:
+
+        /// <summary>
+        /// Handles the event of a new key being added to a region.
+        /// </summary>
+        /// <remarks>
+        /// The entry did not previously exist in this region in the local cache
+        /// (even with a null value).
+        /// <para>
+        /// This function does not throw any exception.
+        /// </para>
+        /// </remarks>
+        /// <param name="ev">
+        /// Denotes the event object associated with the entry creation.
+        /// </param>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        void OnEvent( CqEvent^ ev );
+
+        /// <summary>
+        /// Handles the event of an entry's value being modified in a region.
+        /// </summary>
+        /// <remarks>
+        /// This entry previously existed in this region in the local cache,
+        /// but its previous value may have been null.
+        /// </remarks>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with updating the entry.
+        /// </param>
+        /// <seealso cref="Region.Put" />
+        void OnError( CqEvent^ ev );
+
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources,
+        /// such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// <para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close();
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICqEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICqEvent.hpp b/src/clicache/src/ICqEvent.hpp
new file mode 100644
index 0000000..a847c25
--- /dev/null
+++ b/src/clicache/src/ICqEvent.hpp
@@ -0,0 +1,113 @@
+/*=========================================================================
+ * 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"
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache {
+            //ref class CqOperationType;
+      namespace Generic
+    {
+			 interface class IGFSerializable;
+       
+
+      generic<class TKey, class TResult>
+      ref class CqQuery;
+
+      interface class ICacheableKey;
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// Listener change notifications are invoked <c>after</c>
+      /// the change has occured.
+      /// </summary>
+      /// <remarks>
+      /// Listeners receive notifications when entries in a region change or changes occur to the
+      /// region attributes themselves.
+      /// <para>
+      /// A cache listener is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      /// The methods on a <c>ICacheListener</c>
+      /// are invoked asynchronously. Multiple events can cause concurrent invocation
+      /// of <c>ICacheListener</c> methods.  If event A occurs before event B,
+      /// there is no guarantee that their corresponding <c>ICacheListener</c>
+      /// method invocations will occur in the same order.  Any exceptions thrown by
+      /// the listener are caught by GemFire and logged. 
+      ///
+      /// Listeners are user callbacks that
+      /// are invoked by GemFire. It is important to ensure that minimal work is done in the
+      /// listener before returning control back to GemFire. For example, a listener
+      /// implementation may choose to hand off the event to a thread pool that then processes
+      /// the event on its thread rather than the listener thread
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheListener" />
+      /// <seealso cref="RegionAttributes.CacheListener" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheWriter" />
+      generic<class TKey, class TResult>
+      public interface class ICqEvent
+      {
+      public:
+
+        /// <summary>
+        /// Handles the event of a new key being added to a region.
+        /// </summary>
+        /// <remarks>
+        /// The entry did not previously exist in this region in the local cache
+        /// (even with a null value).
+        /// <para>
+        /// This function does not throw any exception.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        CqQuery<TKey, TResult>^ getCq();
+
+        /// <summary>
+        /// Handles the event of an entry's value being modified in a region.
+        /// </summary>
+        /// <remarks>
+        /// This entry previously existed in this region in the local cache,
+        /// but its previous value may have been null.
+        /// </remarks>
+        /// <seealso cref="Region.Put" />
+        CqOperationType getBaseOperation();
+
+        CqOperationType getQueryOperation();
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources,
+        /// such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// <para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        TKey /*Generic::ICacheableKey^*/ getKey();
+
+        TResult /*Object^*/ getNewValue();
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICqListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICqListener.hpp b/src/clicache/src/ICqListener.hpp
new file mode 100644
index 0000000..8f4dc22
--- /dev/null
+++ b/src/clicache/src/ICqListener.hpp
@@ -0,0 +1,112 @@
+/*=========================================================================
+ * 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 "CqEvent.hpp"
+using namespace System;
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      generic<class TKey, class TResult>
+      ref class CqEvent;
+
+      /// <summary>
+      /// An application plug-in that can be installed on a region.
+      /// Listener change notifications are invoked <c>after</c>
+      /// the change has occured.
+      /// </summary>
+      /// <remarks>
+      /// Listeners receive notifications when entries in a region change or changes occur to the
+      /// region attributes themselves.
+      /// <para>
+      /// A cache listener is defined in the <see cref="RegionAttributes" />.
+      /// </para>
+      /// The methods on a <c>ICacheListener</c>
+      /// are invoked asynchronously. Multiple events can cause concurrent invocation
+      /// of <c>ICacheListener</c> methods.  If event A occurs before event B,
+      /// there is no guarantee that their corresponding <c>ICacheListener</c>
+      /// method invocations will occur in the same order.  Any exceptions thrown by
+      /// the listener are caught by GemFire and logged. 
+      ///
+      /// Listeners are user callbacks that
+      /// are invoked by GemFire. It is important to ensure that minimal work is done in the
+      /// listener before returning control back to GemFire. For example, a listener
+      /// implementation may choose to hand off the event to a thread pool that then processes
+      /// the event on its thread rather than the listener thread
+      /// </remarks>
+      /// <seealso cref="AttributesFactory.SetCacheListener" />
+      /// <seealso cref="RegionAttributes.CacheListener" />
+      /// <seealso cref="ICacheLoader" />
+      /// <seealso cref="ICacheWriter" />
+      //generic<class TKey, class TValue>
+      generic<class TKey, class TResult>
+      public interface class ICqListener
+      {
+      public:
+
+        /// <summary>
+        /// Handles the event of a new key being added to a region.
+        /// </summary>
+        /// <remarks>
+        /// The entry did not previously exist in this region in the local cache
+        /// (even with a null value).
+        /// <para>
+        /// This function does not throw any exception.
+        /// </para>
+        /// </remarks>
+        /// <param name="ev">
+        /// Denotes the event object associated with the entry creation.
+        /// </param>
+        /// <seealso cref="Region.Create" />
+        /// <seealso cref="Region.Put" />
+        /// <seealso cref="Region.Get" />
+        void OnEvent( CqEvent<TKey, TResult>^ ev );
+
+        /// <summary>
+        /// Handles the event of an entry's value being modified in a region.
+        /// </summary>
+        /// <remarks>
+        /// This entry previously existed in this region in the local cache,
+        /// but its previous value may have been null.
+        /// </remarks>
+        /// <param name="ev">
+        /// EntryEvent denotes the event object associated with updating the entry.
+        /// </param>
+        /// <seealso cref="Region.Put" />
+        //generic<class TKey, class TValue>
+        void OnError( CqEvent<TKey, TResult>^ ev );
+
+
+        /// <summary>
+        /// Called when the region containing this callback is destroyed, when
+        /// the cache is closed.
+        /// </summary>
+        /// <remarks>
+        /// Implementations should clean up any external resources,
+        /// such as database connections. Any runtime exceptions this method
+        /// throws will be logged.
+        /// <para>
+        /// It is possible for this method to be called multiple times on a single
+        /// callback instance, so implementations must be tolerant of this.
+        /// </para>
+        /// </remarks>
+        /// <seealso cref="Cache.Close" />
+        /// <seealso cref="Region.DestroyRegion" />
+        void Close();
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICqResults.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICqResults.hpp b/src/clicache/src/ICqResults.hpp
new file mode 100644
index 0000000..77fb9d4
--- /dev/null
+++ b/src/clicache/src/ICqResults.hpp
@@ -0,0 +1,41 @@
+/*=========================================================================
+ * 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 <gfcpp/SelectResults.hpp>
+//#include "impl/NativeWrapper.hpp"
+#include "ISelectResults.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      generic<class TResult>
+      ref class SelectResultsIterator;
+
+      /// <summary>
+      /// Interface to encapsulate a select query result set.
+      /// </summary>
+      generic<class TResult>
+      public interface class ICqResults
+        : public ISelectResults<TResult>
+      {
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/ICqStatusListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ICqStatusListener.hpp b/src/clicache/src/ICqStatusListener.hpp
new file mode 100644
index 0000000..aa63b04
--- /dev/null
+++ b/src/clicache/src/ICqStatusListener.hpp
@@ -0,0 +1,49 @@
+/*=========================================================================
+* 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 "ICqListener.hpp"
+
+using namespace System;
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache 
+    { 
+      namespace Generic
+      {
+
+        /// <summary>
+        /// Extension of CqListener. Adds two new methods to CqListener, one that
+        /// is called when the cq is connected and one that is called when
+        /// the cq is disconnected.
+        /// </summary>
+
+        generic<class TKey, class TResult>
+        public interface class ICqStatusListener : public ICqListener<TKey, TResult>
+        {
+        public:
+
+          /// <summary>
+          /// Called when the cq loses connection with all servers.
+          /// </summary>
+          virtual void OnCqDisconnected();
+
+          /// <summary>
+          /// Called when the cq establishes a connection with a server
+          /// </summary>
+          virtual void OnCqConnected(); 
+
+        };
+      }
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/IFixedPartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/IFixedPartitionResolver.hpp b/src/clicache/src/IFixedPartitionResolver.hpp
new file mode 100644
index 0000000..17d90f6
--- /dev/null
+++ b/src/clicache/src/IFixedPartitionResolver.hpp
@@ -0,0 +1,91 @@
+/*=========================================================================
+ * 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 "IPartitionResolver.hpp"
+
+//using System::Collections::Generics;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      ref class EntryEvent;
+      interface class IGFSerializable;
+      namespace Generic
+      {
+        /// <summary>
+        /// Implementers of interface <code>FixedPartitionResolver</code> helps to
+        /// achieve explicit mapping of a "user defined" partition to a data member node.
+        /// </summary>
+        /// <remarks>
+        /// <p>
+        /// GemFire uses the partition name returned by 
+        /// {@link FixedPartitionResolver#getPartitionName(EntryEvent, CacheableHashSet)}
+        /// to determine on which member the data is being managed. Say, for example, you want to
+        /// partition all Trades according to quarters. You can implement
+        /// FixedPartitionResolver to get the name of the quarter based on the date given
+        /// as part of {@link EntryEvent}.
+        /// </p>
+        ///  
+        /// public class QuarterPartitionResolver implements FixedPartitionResolver{<br>
+        /// &nbsp &nbsp public String getPartitionName(EntryOperation opDetails, CacheableHashSet
+        /// allAvailablePartitions) {<br>
+        /// &nbsp &nbsp Date date = sdf.parse((String)opDetails.getKey());<br>
+        /// &nbsp &nbsp Calendar cal = Calendar.getInstance();<br>
+        /// &nbsp &nbsp cal.setTime(date);<br>
+        /// &nbsp &nbsp int month = cal.get(Calendar.MONTH);<br>
+        /// &nbsp &nbsp if (month == 0 || month == 1 || month == 2) {<br>
+        /// &nbsp &nbsp &nbsp return "Quarter1";<br>
+        /// &nbsp &nbsp }<br>
+        /// &nbsp &nbsp else if (month == 3 || month == 4 || month == 5) {<br>
+        /// &nbsp &nbsp &nbsp return "Quarter2";<br>
+        /// &nbsp &nbsp }<br>
+        /// &nbsp &nbsp else if (month == 6 || month == 7 || month == 8) {<br>
+        /// &nbsp &nbsp &nbsp return "Quarter3";<br>
+        /// &nbsp &nbsp }<br>
+        /// &nbsp &nbsp else if (month == 9 || month == 10 || month == 11) {<br>
+        /// &nbsp &nbsp &nbsp return "Quarter4";<br>
+        /// &nbsp &nbsp }<br>
+        /// &nbsp &nbsp else {<br>
+        /// &nbsp &nbsp &nbsp return "Invalid Quarter";<br>
+        /// &nbsp &nbsp }<br>
+        /// &nbsp }<br>
+        ///
+        /// @see PartitionResolver
+        ///
+        /// </remarks>
+        /// <seealso cref="AttributesFactory.SetPartitionResolver" />
+        /// <seealso cref="RegionAttributes.PartitionResolver" />
+        generic<class TKey, class TValue>
+        public interface class IFixedPartitionResolver: public IPartitionResolver<TKey, TValue>
+        {
+        public:
+
+         /// <summary>
+         /// This method is used to get the name of the partition for the given entry
+         /// operation.
+         /// </summary> 
+         /// <param name="opDetails"> 
+         /// the details of the entry event e.g. {@link Region#get(Object)}
+         /// </param>
+         /// <return> partition-name associated with node which allows mapping of given
+         /// data to user defined partition
+         /// </return>         
+          String^ GetPartitionName(EntryEvent<TKey, TValue>^ opDetails);
+        };
+      }
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/IGFDelta.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/IGFDelta.hpp b/src/clicache/src/IGFDelta.hpp
new file mode 100644
index 0000000..e132e8f
--- /dev/null
+++ b/src/clicache/src/IGFDelta.hpp
@@ -0,0 +1,70 @@
+/*=========================================================================
+ * Copyright (c) 2010-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
+ * one or more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+#pragma once
+
+#include "gf_defs.hpp"
+
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      ref class DataOutput;
+      ref class DataInput;
+      ref class Serializable;
+
+      /// <summary>
+      /// This interface is used for delta propagation.
+      /// To use delta propagation, an application class must implement interfaces <c>IGFDelta</c> as well as <c>IGFSerializable</c>.
+      /// The <c>IGFDelta</c> interface methods <c>HasDelta( ), ToDelta( )</c> and <c>FromDelta( )</c> must be implemented by the class, as these methods are used by GemFire
+      /// to detect the presence of delta in an object, to serialize the delta, and to apply a serialized delta to an existing object
+      /// of the class.
+      /// If a customized cloning method is required, the class must also implement the interface <c>System.ICloneable</c>.
+      /// To use cloning in delta propagation for a region, the region attribute for cloning must be enabled.
+      /// </summary>
+      public interface class IGFDelta
+      {
+      public:
+        
+        /// <summary>
+        /// Writes out delta information to out in a user-defined format. This is
+        /// invoked on an application object after GemFire determines the presence
+        /// of delta in it by calling <c>HasDelta()</c> on the object.
+        /// </summary>
+        /// <exception cref="GemFireIOException">
+        /// </exception>
+        void ToDelta( DataOutput^ out );
+
+        /// <summary>
+        /// Reads in delta information to this object in a user-defined format. This is
+        /// invoked on an existing application object after GemFire determines the
+        /// presence of delta in <c>DataInput</c> instance.
+        /// </summary>
+        /// <exception cref="InvalidDeltaException">
+        /// if the delta in the <c>DataInput</c> instance cannot be applied
+        /// to this instance (possible causes may include mismatch of Delta version or logic error).
+        /// </exception>
+        /// <exception cref="GemFireIOException">
+        /// </exception>
+        void FromDelta( DataInput^ in );
+       
+        /// <summary>
+        /// <c>HasDelta( )</c> is invoked by GemFire during <c>Region.Put( ICacheableKey, IGFSerializable )</c> to determine if the object contains a delta.
+        /// If <c>HasDelta( )</c> returns true, the delta in the object is serialized by invoking <c>ToDelta( DataOutput )</c>.
+        /// If <c>HasDelta( )</c> returns false, the object is serialized by invoking <c>IGFSerializable.ToData( DataOutput )</c>.
+        /// </summary>
+        bool HasDelta( );
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/IGFSerializable.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/IGFSerializable.hpp b/src/clicache/src/IGFSerializable.hpp
new file mode 100644
index 0000000..46ea34d
--- /dev/null
+++ b/src/clicache/src/IGFSerializable.hpp
@@ -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.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "gfcpp/gf_types.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Generic
+      {
+
+      ref class DataOutput;
+      ref class DataInput;
+      ref class Serializable;
+
+      /// <summary>
+      /// This interface class is the superclass of all user objects 
+      /// in the cache that can be serialized.
+      /// </summary>
+      public interface class IGFSerializable
+      {
+      public:
+
+        /// <summary>
+        /// Serializes this object.
+        /// </summary>
+        /// <param name="output">
+        /// the DataOutput object to use for serializing the object
+        /// </param>
+        void ToData( DataOutput^ output );
+
+        //bool HasDelta();
+
+        /// <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>
+        IGFSerializable^ FromData( DataInput^ input );
+
+        /// <summary>
+        /// Get the size of this object in bytes.
+        /// This is only needed if you use the HeapLRU feature.
+        /// </summary>
+        /// <remarks>
+        /// Note that you can simply return zero if you are not using the HeapLRU feature.
+        /// </remarks>
+        /// <returns>the size of this object in bytes.</returns>
+        property uint32_t ObjectSize
+        {
+          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>
+        /// <remarks>
+        /// The classId must be unique within an application suite
+        /// and in the range 0 to ((2^31)-1) both inclusive. An application can
+        /// thus define upto 2^31 custom <c>IGFSerializable</c> classes.
+        /// Returning a value greater than ((2^31)-1) may result in undefined
+        /// behaviour.
+        /// </remarks>
+        /// <returns>the classId</returns>
+        property uint32_t ClassId
+        {
+          uint32_t get( );
+        }
+
+        /// <summary>
+        /// Return a string representation of the object.
+        /// </summary>
+        String^ ToString( );
+      };
+      } // end namespace generic
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/IGemFireCache.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/IGemFireCache.hpp b/src/clicache/src/IGemFireCache.hpp
new file mode 100644
index 0000000..f490f7d
--- /dev/null
+++ b/src/clicache/src/IGemFireCache.hpp
@@ -0,0 +1,102 @@
+/*=========================================================================
+ * 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 "IRegionService.hpp"
+#include "DistributedSystem.hpp"
+#include "CacheTransactionManager.hpp"
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Generic
+      {
+      /// <summary>
+      /// GemFireCache represents the singleton cache that must be created
+      /// in order to connect to Gemfire server.
+      /// </summary>
+      /// <remarks>
+      /// Caches are obtained from Crest methods on the
+      /// <see cref="CacheFactory.Create"/> class.
+      /// <para>
+      /// When a cache is created a <see cref="DistributedSystem" />
+      /// must be specified.
+      /// </para><para>
+      /// When a cache will no longer be used, call <see cref="Cache.Close" />.
+      /// Once it <see cref="Cache.IsClosed" /> any attempt to use it
+      /// will cause a <c>CacheClosedException</c> to be thrown.
+      /// </para><para>
+      /// A cache can have multiple root regions, each with a different name.
+      /// </para>
+      /// </remarks>
+      public interface class IGemFireCache : IRegionService
+      {
+      public:        
+        
+        /// <summary>
+        /// Returns the name of this cache.
+        /// </summary>
+        /// <remarks>
+        /// This method does not throw
+        /// <c>CacheClosedException</c> if the cache is closed.
+        /// </remarks>
+        /// <returns>the string name of this cache</returns>
+        property String^ Name
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Initializes the cache from an XML file.
+        /// </summary>
+        /// <param name="cacheXml">pathname of a <c>cache.xml</c> file</param>
+        void InitializeDeclarativeCache( String^ cacheXml );
+
+        /// <summary>
+        /// Returns the distributed system used to
+        /// <see cref="CacheFactory.Create" /> this cache.
+        /// </summary>
+        /// <remarks>
+        /// This method does not throw
+        /// <c>CacheClosedException</c> if the cache is closed.
+        /// </remarks>
+        property DistributedSystem^ DistributedSystem
+        {
+          GemStone::GemFire::Cache::Generic::DistributedSystem^ get( );
+        } 
+
+        /// <summary>
+        /// Returns the cache transaction manager of
+        /// <see cref="CacheFactory.Create" /> this cache.
+        /// </summary>
+        property GemStone::GemFire::Cache::Generic::CacheTransactionManager^ CacheTransactionManager
+        {
+          GemStone::GemFire::Cache::Generic::CacheTransactionManager^ get( );
+        }
+
+				///<summary>
+				/// Returns whether Cache saves unread fields for Pdx types.
+				///</summary>
+				bool GetPdxIgnoreUnreadFields();
+
+        ///<summary>
+        /// Returns whether { @link PdxInstance} is preferred for PDX types instead of .NET object.
+        ///</summary>
+        bool GetPdxReadSerialized();
+      };
+      } // end namespace Generic      
+    }
+  }
+}


Mime
View raw message