geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject [02/51] [partial] geode git commit: Software Grant Agreement (SGA) from Pivotal for Apache Geode
Date Fri, 13 Jan 2017 22:45:46 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/LocalRegion.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/LocalRegion.hpp b/src/clicache/src/LocalRegion.hpp
new file mode 100644
index 0000000..2fde3d1
--- /dev/null
+++ b/src/clicache/src/LocalRegion.hpp
@@ -0,0 +1,240 @@
+/*=========================================================================
+ * 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/Cache.hpp>
+//#include "impl/NativeWrapper.hpp"
+#include "IRegion.hpp"
+#include "Log.hpp"
+#include "ExceptionTypes.hpp"
+#include "RegionAttributes.hpp"
+
+using namespace System;
+using namespace System::Collections::Generic;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      generic<class TKey, class TValue>
+      ref class RegionEntry;
+
+      generic<class TKey, class TValue>
+      ref class AttributesMutator;
+
+      generic<class TKey, class TValue>
+			public ref class LocalRegion : public Generic::Internal::SBWrap<gemfire::Region>, public IRegion<TKey, TValue>  
+      {
+      public:
+
+          virtual property TValue default[TKey]
+          {
+            TValue get(TKey key);
+            void set(TKey key, TValue value);
+          }         
+                    
+          virtual System::Collections::Generic::IEnumerator<KeyValuePair<TKey,TValue>>^ GetEnumerator();
+          
+          virtual System::Collections::IEnumerator^ GetEnumeratorOld() = 
+            System::Collections::IEnumerable::GetEnumerator;
+
+          virtual bool ContainsKey(TKey key);
+          
+          virtual void Add(TKey key, TValue val);
+          
+          virtual void Add(KeyValuePair<TKey, TValue> keyValuePair);
+          
+          virtual void Add(TKey key, TValue value, Object^ callbackArg);
+
+          virtual bool Remove(TKey key);        
+
+          virtual bool Remove( TKey key, Object^ callbackArg );      
+
+          virtual bool Remove(KeyValuePair<TKey,TValue> keyValuePair);          
+
+          virtual bool Remove(TKey key, TValue value, Object^ callbackArg );          
+
+          virtual bool Contains(KeyValuePair<TKey,TValue> keyValuePair);          
+
+          virtual void Clear();  
+
+          virtual void Clear(Object^ callbackArg);
+
+          virtual void CopyTo(array<KeyValuePair<TKey,TValue>>^ toArray, int startIdx);                   
+
+          virtual bool TryGetValue(TKey key, TValue %val);
+          
+          virtual property int Count
+          {
+            int get();
+          }
+
+          virtual property bool IsReadOnly
+          {
+            bool get() {throw gcnew System::NotImplementedException;/*return false;*/}
+          }
+          
+          virtual property System::Collections::Generic::ICollection<TKey>^ Keys
+          {
+            System::Collections::Generic::ICollection<TKey>^ get();
+          }
+
+          virtual property System::Collections::Generic::ICollection<TValue>^ Values
+          {
+            System::Collections::Generic::ICollection<TValue>^ get();
+          }
+
+          virtual void Put(TKey key, TValue value, Object^ callbackArg);
+
+          virtual TValue Get(TKey key, Object^ callbackArg);
+
+          virtual void InvalidateRegion();
+
+          virtual void InvalidateRegion(Object^ callbackArg);
+
+          virtual void DestroyRegion();
+
+          virtual void DestroyRegion(Object^ callbackArg);
+
+          virtual void Invalidate(TKey key);
+
+          virtual void Invalidate(TKey key, Object^ callbackArg);
+
+          virtual void PutAll(System::Collections::Generic::IDictionary<TKey, TValue>^ map);
+
+          virtual void PutAll(System::Collections::Generic::IDictionary<TKey, TValue>^ map, int timeout);
+
+          virtual void PutAll(System::Collections::Generic::IDictionary<TKey, TValue>^ map, int timeout, Object^ callbackArg);
+
+          virtual void GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
+            System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
+            System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions);
+
+          virtual void GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
+            System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
+            System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions,
+            bool addToLocalCache);
+
+          virtual void GetAll(System::Collections::Generic::ICollection<TKey>^ keys, 
+            System::Collections::Generic::IDictionary<TKey, TValue>^ values, 
+            System::Collections::Generic::IDictionary<TKey, System::Exception^>^ exceptions,
+            bool addToLocalCache, Object^ callbackArg);
+          
+          virtual void RemoveAll(System::Collections::Generic::ICollection<TKey>^ keys);
+          virtual void RemoveAll(System::Collections::Generic::ICollection<TKey>^ keys,
+            Object^ callbackArg);
+
+          virtual property String^ Name
+          { 
+            String^ get();
+          } 
+
+          virtual property String^ FullPath
+          {
+            String^ get();
+          }
+
+          virtual property IRegion<TKey, TValue>^ ParentRegion
+          {
+            IRegion<TKey, TValue>^ get( );
+          }
+
+          virtual property RegionAttributes<TKey, TValue>^ Attributes 
+          {
+            RegionAttributes<TKey, TValue>^ get();
+          }
+
+          virtual property AttributesMutator<TKey, TValue>^ AttributesMutator
+          {
+            GemStone::GemFire::Cache::Generic::AttributesMutator<TKey, TValue>^ get();
+          }
+
+          virtual property GemStone::GemFire::Cache::Generic::CacheStatistics^ Statistics 
+          {
+            GemStone::GemFire::Cache::Generic::CacheStatistics^ get();
+          }
+
+          virtual IRegion<TKey, TValue>^ GetSubRegion( String^ path );
+          
+          virtual IRegion<TKey, TValue>^ CreateSubRegion( String^ subRegionName,
+            RegionAttributes<TKey,TValue>^ attributes );
+
+          virtual System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ SubRegions( bool recursive );
+
+          virtual RegionEntry<TKey, TValue>^ GetEntry( TKey key );
+
+          virtual System::Collections::Generic::ICollection<RegionEntry<TKey,TValue>^>^ GetEntries(bool recursive);
+
+          virtual property GemStone::GemFire::Cache::Generic::IRegionService^ RegionService
+          {
+            GemStone::GemFire::Cache::Generic::IRegionService^ get( );
+          }
+
+          virtual bool ContainsValueForKey( TKey key );
+
+          //Additional Region properties and methods
+          virtual property bool IsDestroyed
+          {
+            bool get();
+          }
+          
+          generic<class TResult>
+          virtual ISelectResults<TResult>^ Query( String^ predicate );
+
+          generic<class TResult>
+          virtual ISelectResults<TResult>^ Query( String^ predicate, uint32_t timeout );
+
+          virtual bool ExistsValue( String^ predicate );
+
+          virtual bool ExistsValue( String^ predicate, uint32_t timeout );
+
+          virtual Object^ SelectValue( String^ predicate );
+
+          virtual Object^ SelectValue( String^ predicate, uint32_t timeout );
+
+          virtual ISubscriptionService<TKey>^ GetSubscriptionService();
+
+          virtual IRegion<TKey, TValue>^ GetLocalView();
+
+
+      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>
+        //generic<class TKey, class TValue>
+        inline static IRegion<TKey, TValue>^ Create( gemfire::Region* nativeptr )
+        {
+          return ( nativeptr != nullptr ?
+            gcnew LocalRegion<TKey, TValue>( nativeptr ) : nullptr );
+        }
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline LocalRegion( gemfire::Region* nativeptr )
+          : SBWrap( nativeptr ) { }
+
+        private:        
+        inline gemfire::SerializablePtr getRegionEntryValue(gemfire::CacheableKeyPtr& key);
+        bool AreValuesEqual(gemfire::CacheablePtr& val1, gemfire::CacheablePtr& val2);
+      };
+
+
+    }
+  }
+} } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/Log.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Log.cpp b/src/clicache/src/Log.cpp
new file mode 100644
index 0000000..7ed7ddd
--- /dev/null
+++ b/src/clicache/src/Log.cpp
@@ -0,0 +1,116 @@
+/*=========================================================================
+ * 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 "Log.hpp"
+#include "impl/ManagedString.hpp"
+#include "impl/SafeConvert.hpp"
+#include "ExceptionTypes.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Generic
+      {
+      void Log::Init( LogLevel level, String^ logFileName )
+      {
+        _GF_MG_EXCEPTION_TRY2
+
+          ManagedString mg_lfname( logFileName );
+          gemfire::Log::init( static_cast<gemfire::Log::LogLevel>( level ),
+            mg_lfname.CharPtr );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2
+      }
+
+      void Log::Init( LogLevel level, String^ logFileName, int32_t logFileLimit )
+      {
+        _GF_MG_EXCEPTION_TRY2
+
+          ManagedString mg_lfname( logFileName );
+          gemfire::Log::init( static_cast<gemfire::Log::LogLevel>( level ),
+            mg_lfname.CharPtr, logFileLimit );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2
+      }
+
+      void Log::Close( )
+      {
+        gemfire::Log::close( );
+      }
+
+      LogLevel Log::Level( )
+      {
+        return static_cast<LogLevel>( gemfire::Log::logLevel( ) );
+      }
+
+      void Log::SetLevel( LogLevel level )
+      {
+        gemfire::Log::setLogLevel(
+          static_cast<gemfire::Log::LogLevel>( level ) );
+      }
+
+      String^ Log::LogFileName( )
+      {
+        _GF_MG_EXCEPTION_TRY2
+
+          return ManagedString::Get( gemfire::Log::logFileName( ) );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2
+      }
+
+      bool Log::Enabled( LogLevel level )
+      {
+        return gemfire::Log::enabled(
+          static_cast<gemfire::Log::LogLevel>( level ) );
+      }
+
+      void Log::Write( LogLevel level, String^ msg )
+      {
+        _GF_MG_EXCEPTION_TRY2
+
+          ManagedString mg_msg( msg );
+          gemfire::Log::log( static_cast<gemfire::Log::LogLevel>( level ),
+            mg_msg.CharPtr );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2
+      }
+
+      void Log::LogThrow( LogLevel level, String^ msg, System::Exception^ ex )
+      {
+        if ( ex != nullptr )
+        {
+          String^ logMsg = String::Format(
+            System::Globalization::CultureInfo::CurrentCulture,
+            "GemFire exception {0} thrown: {1}{2}{3}", ex->GetType( ),
+            ex->Message, Environment::NewLine, msg );
+          Log::Write( level, logMsg );
+        }
+      }
+
+      void Log::LogCatch( LogLevel level, String^ msg, System::Exception^ ex )
+      {
+        if ( ex != nullptr )
+        {
+          String^ logMsg = String::Format(
+            System::Globalization::CultureInfo::CurrentCulture,
+            "GemFire exception {0} caught: {1}{2}{3}", ex->GetType( ),
+            ex->Message, Environment::NewLine, msg );
+          Log::Write( level, logMsg );
+        }
+      }
+      } // end namespace generic
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/Log.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Log.hpp b/src/clicache/src/Log.hpp
new file mode 100644
index 0000000..21966df
--- /dev/null
+++ b/src/clicache/src/Log.hpp
@@ -0,0 +1,320 @@
+/*=========================================================================
+ * 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/Log.hpp>
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      namespace Generic
+      {
+
+      /// <summary>
+      /// Logging levels.
+      /// </summary>
+      public enum class LogLevel
+      {
+        /// <summary>
+        /// No log.
+        /// </summary>
+        Null = 0,
+
+        /// <summary>
+        /// Indicates serious failure.
+        /// </summary>
+        Error,
+        /// <summary>
+        /// Indicates potential problem.
+        /// </summary>
+        Warning,
+        /// <summary>
+        /// For informational purpose.
+        /// </summary>
+        Info,
+
+        /// <summary>
+        /// The default logging level.
+        /// </summary>
+        Default,
+
+        /// <summary>
+        /// For Static configuration messages.
+        /// </summary>
+        Config,
+
+        /// <summary>
+        /// For tracing information.
+        /// </summary>
+        Fine,
+        /// <summary>
+        /// For moderately detailed tracing information.
+        /// </summary>
+        Finer,
+        /// <summary>
+        /// For very detailed tracing information.
+        /// </summary>
+        Finest,
+
+        /// <summary>
+        /// For highly detailed tracing information.
+        /// </summary>
+        Debug,
+
+        /// <summary>
+        /// All the log messages.
+        /// </summary>
+        All,
+      };
+
+
+      /// <summary>
+      /// Defines methods available to clients that want to write a log message
+      /// to their GemFire system's shared log file.
+      /// </summary>
+      /// <remarks>
+      /// Any attempt to use an instance after its connection is disconnected
+      /// will throw a <c>NotConnectedException</c>.
+      /// <para>
+      /// For any logged message the log file will contain:
+      /// <ul>
+      /// <li> The message's log level.</li>
+      /// <li> The time the message was logged.</li>
+      /// <li> The ID of the connection and thread that logged the message.</li>
+      /// <li> The message itself, perhaps with
+      /// an exception including the exception's stack trace.</li>
+      /// </ul>
+      /// </para><para>
+      /// A message always has a level.
+      /// Logging levels are ordered. Enabling logging at a given level also
+      /// enables logging at higher levels. The higher the level the more
+      /// important and urgent the message.
+      /// </para><para>
+      /// The levels, in descending order of severity, are:
+      /// <ul>
+      ///
+      /// <li> <c>Error</c> (highest severity) is a message level
+      /// indicating a serious failure.  In general <c>error</c>
+      /// messages should describe events that are of considerable
+      /// importance and which will prevent normal program execution. They
+      /// should be reasonably intelligible to end users and to system
+      /// administrators.</li>
+      ///
+      /// <li> <c>Warning</c> is a message level indicating a
+      /// potential problem.  In general <c>warning</c> messages
+      /// should describe events that will be of interest to end users or
+      /// system managers, or which indicate potential problems.</li>
+      ///
+      /// <li> <c>Info</c> is a message level for informational
+      /// messages.  Typically <c>info</c> messages should be
+      /// reasonably significant and should make sense to end users and
+      /// system administrators.</li>
+      ///
+      /// <li> <c>Config</c> is a message level for static
+      /// configuration messages.  <c>config</c> messages are intended
+      /// to provide a variety of static configuration information, to
+      /// assist in debugging problems that may be associated with
+      /// particular configurations.</li>
+      ///
+      /// <li> <c>Fine</c> is a message level providing tracing
+      /// information.  In general the <c>fine</c> level should be
+      /// used for information that will be broadly interesting to
+      /// developers. This level is for the lowest volume, and most
+      /// important, tracing messages.</li>
+      ///
+      /// <li> <c>Finer</c> indicates a moderately detailed tracing
+      /// message.  This is an intermediate level between <c>fine</c>
+      /// and <c>finest</c>.</li>
+      ///
+      /// <li> <c>Finest</c> indicates a very detailed tracing
+      /// message.  Logging calls for entering, returning, or throwing an
+      /// exception are traced at the <c>finest</c> level.</li>
+      ///
+      /// <li> <c>Debug</c> (lowest severity) indicates a highly
+      /// detailed tracing message.  In general the <c>debug</c> level
+      /// should be used for the most voluminous detailed tracing messages.</li>
+      /// </ul>
+      ///
+      /// </para>
+      /// </remarks>
+      public ref class Log STATICCLASS
+      {
+      public:
+
+
+
+        /// <summary>
+        /// Initializes the logging facility with the given level and filename.
+        /// </summary>
+        /// <param name="level">the logging level</param>
+        /// <param name="logFileName">the log file name</param>
+        static void Init( LogLevel level, String^ logFileName );
+
+        /// <summary>
+        /// Initializes logging facility with given level, filename, and file size limit.
+        /// </summary>
+        /// <param name="level">the logging level</param>
+        /// <param name="logFileName">the log file name</param>
+        /// <param name="logFileLimit">maximum allowable size of the log file, in bytes, 
+        ///        or 0 for the default (1 Gbyte)</param>
+        static void Init( LogLevel level, String^ logFileName, int32_t logFileLimit );
+
+        /// <summary>
+        /// Closes logging facility (until next init).
+        /// </summary>
+        static void Close( );
+
+        /// <summary>
+        /// Returns the current log level.
+        /// </summary>
+        static LogLevel Level( );
+
+        /// <summary>
+        /// Sets the current log level.
+        /// </summary>
+        static void SetLevel( LogLevel level );
+
+        /// <summary>
+        /// Returns the name of the current log file.
+        /// NOTE: This function is for debugging only, as it is not completely
+        /// thread-safe!
+        /// </summary>
+        static String^ LogFileName( );
+
+        /// <summary>
+        /// True if log messages at the given level are enabled.
+        /// </summary>
+        static bool Enabled( LogLevel level );
+
+        /// <summary>
+        /// Logs a message at the given level.
+        /// </summary>
+        static void Write( LogLevel level, String^ msg );
+
+        /// <summary>
+        /// Logs both a message and a thrown exception.
+        /// </summary>
+        static void LogThrow( LogLevel level, String^ msg, System::Exception^ ex );
+
+        /// <summary>
+        /// Logs both a message and a caught exception.
+        /// </summary>
+        static void LogCatch( LogLevel level, String^ msg, System::Exception^ ex );
+
+        // Convenience functions with variable number of arguments
+        // as in String.Format
+
+        /// <summary>
+        /// Error level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Error( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Error)
+            Log::Write( LogLevel::Error, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Warning level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Warning( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Warning)
+            Log::Write( LogLevel::Warning, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Info level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Info( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Info)
+            Log::Write( LogLevel::Info, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Config level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Config( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Config)
+            Log::Write( LogLevel::Config, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Fine level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Fine( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Fine)
+            Log::Write( LogLevel::Fine, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Finer level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Finer( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Finer)
+            Log::Write( LogLevel::Finer, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Finest level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Finest( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Finest)
+            Log::Write( LogLevel::Finest, String::Format(
+              System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+
+        /// <summary>
+        /// Debug level logging with variable number of arguments using
+        /// format as in <c>System.String.Format</c>.
+        /// </summary>
+        inline static void Debug( String^ format, ... array<Object^>^ args )
+        {
+          if(staticLogLevel >= LogLevel::Debug)
+          Log::Write( LogLevel::Debug, String::Format(
+            System::Globalization::CultureInfo::CurrentCulture, format, args ) );
+        }
+      internal:
+
+        static void SetLogLevel( LogLevel level)
+        {
+          staticLogLevel = level;
+        }
+
+       private:
+         static LogLevel staticLogLevel =  LogLevel::Null;
+      };
+      } // end namespace Generic
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/PdxIdentityFieldAttribute.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/PdxIdentityFieldAttribute.hpp b/src/clicache/src/PdxIdentityFieldAttribute.hpp
new file mode 100755
index 0000000..a726b4b
--- /dev/null
+++ b/src/clicache/src/PdxIdentityFieldAttribute.hpp
@@ -0,0 +1,43 @@
+/*=========================================================================
+ * 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"
+using namespace System;
+using namespace System::Reflection;
+
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+			namespace Generic
+			{    
+        ///<summary>        
+        /// PdxIdentityField attribute one can specify on member fields.
+        /// This attribute is used by <see cref="ReflectionBasedAutoSerializer">,
+        /// When it serializes the fields in Pdx <see cref="IPdxSerializable"> format.
+        /// This fields will be treated as identity fields for hashcode and equals methods.
+        ///<summary>        
+
+      [AttributeUsage(AttributeTargets::Field)]
+      public ref class PdxIdentityFieldAttribute : Attribute
+      {
+      public:
+
+        PdxIdentityFieldAttribute()
+        {
+        }
+      };
+      }
+    }
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/Pool.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Pool.cpp b/src/clicache/src/Pool.cpp
new file mode 100644
index 0000000..4f02ce9
--- /dev/null
+++ b/src/clicache/src/Pool.cpp
@@ -0,0 +1,232 @@
+/*=========================================================================
+ * 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 "Pool.hpp"
+#include "QueryService.hpp"
+#include "CacheableString.hpp"
+#include "Cache.hpp"
+#include "Properties.hpp"
+#include "impl/ManagedString.hpp"
+#include "ExceptionTypes.hpp"
+#include "impl/SafeConvert.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      //generic<class TKey, class TValue>
+      String^ Pool/*<TKey, TValue>*/::Name::get( )
+      {
+        return ManagedString::Get( NativePtr->getName( ) );
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::FreeConnectionTimeout::get()
+      {
+        return NativePtr->getFreeConnectionTimeout();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::LoadConditioningInterval::get()
+      {
+        return NativePtr->getLoadConditioningInterval();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::SocketBufferSize::get()
+      {
+        return NativePtr->getSocketBufferSize();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::ReadTimeout::get()
+      {
+        return NativePtr->getReadTimeout();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::MinConnections::get()
+      {
+        return NativePtr->getMinConnections();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::MaxConnections::get()
+      {
+        return NativePtr->getMaxConnections();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::IdleTimeout::get()
+      {
+        return NativePtr->getIdleTimeout();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::PingInterval::get()
+      {
+        return NativePtr->getPingInterval();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::UpdateLocatorListInterval::get()
+      {
+        return NativePtr->getUpdateLocatorListInterval();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::StatisticInterval::get()
+      {
+        return NativePtr->getStatisticInterval();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::RetryAttempts::get()
+      {
+        return NativePtr->getRetryAttempts();
+      }
+
+      //generic<class TKey, class TValue>
+      Boolean Pool/*<TKey, TValue>*/::SubscriptionEnabled::get()
+      {
+        return NativePtr->getSubscriptionEnabled();
+      }
+
+      //generic<class TKey, class TValue>
+      Boolean Pool/*<TKey, TValue>*/::PRSingleHopEnabled::get()
+      {
+        return NativePtr->getPRSingleHopEnabled();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::SubscriptionRedundancy::get()
+      {
+        return NativePtr->getSubscriptionRedundancy();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::SubscriptionMessageTrackingTimeout::get()
+      {
+        return NativePtr->getSubscriptionMessageTrackingTimeout();
+      }
+
+      //generic<class TKey, class TValue>
+      Int32 Pool/*<TKey, TValue>*/::SubscriptionAckInterval::get()
+      {
+        return NativePtr->getSubscriptionAckInterval();
+      }
+
+      //generic<class TKey, class TValue>
+      String^ Pool/*<TKey, TValue>*/::ServerGroup::get( )
+      {
+        return ManagedString::Get( NativePtr->getServerGroup( ) );
+      }
+
+      //generic<class TKey, class TValue>
+      array<String^>^ Pool/*<TKey, TValue>*/::Locators::get()
+      {
+        gemfire::CacheableStringArrayPtr locators = NativePtr->getLocators();
+        int length = locators->length();
+        if (length > 0)
+        {
+          array<String^>^ result = gcnew array<String^>(length);
+          for (int item = 0; item < length; item++)
+          {
+            result[item] = CacheableString::GetString(locators[item].ptr());
+          }
+          return result;
+        }
+        else
+        {
+          return nullptr;
+        }
+      }
+
+      //generic<class TKey, class TValue>
+      array<String^>^ Pool/*<TKey, TValue>*/::Servers::get()
+      {
+        gemfire::CacheableStringArrayPtr servers = NativePtr->getServers();
+        int length = servers->length();
+        if (length > 0)
+        {
+          array<String^>^ result = gcnew array<String^>(length);
+          for (int item = 0; item < length; item++)
+          {
+            result[item] = CacheableString::GetString(servers[item].ptr());
+          }
+          return result;
+        }
+        else
+        {
+          return nullptr;
+        }
+      }
+
+	  //generic<class TKey, class TValue>
+      Boolean Pool/*<TKey, TValue>*/::ThreadLocalConnections::get()
+      {
+        return NativePtr->getThreadLocalConnections();
+      }
+
+      //generic<class TKey, class TValue>
+      bool Pool/*<TKey, TValue>*/::MultiuserAuthentication::get()
+      {
+        return NativePtr->getMultiuserAuthentication();    
+      }
+      
+      //generic<class TKey, class TValue>
+      void Pool/*<TKey, TValue>*/::Destroy(Boolean KeepAlive)
+      {
+        NativePtr->destroy(KeepAlive);
+      }
+
+      void Pool::ReleaseThreadLocalConnection()
+      {
+        NativePtr->releaseThreadLocalConnection();
+      }
+
+      //generic<class TKey, class TValue>
+      void Pool/*<TKey, TValue>*/::Destroy()
+      {
+        NativePtr->destroy();
+      }
+
+      //generic<class TKey, class TValue>
+      Boolean Pool/*<TKey, TValue>*/::Destroyed::get()
+      {
+        return NativePtr->isDestroyed();
+      }
+
+      generic<class TKey, class TResult>
+      QueryService<TKey, TResult>^ Pool/*<TKey, TValue>*/::GetQueryService()
+      {
+        _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          return QueryService<TKey, TResult>::Create( NativePtr->getQueryService( ).ptr( ) );
+
+        _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+      }
+      
+      Int32 Pool::PendingEventCount::get()
+      {
+        _GF_MG_EXCEPTION_TRY2
+
+        return NativePtr->getPendingEventCount();
+
+        _GF_MG_EXCEPTION_CATCH_ALL2
+      }
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/Pool.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Pool.hpp b/src/clicache/src/Pool.hpp
new file mode 100644
index 0000000..27017f4
--- /dev/null
+++ b/src/clicache/src/Pool.hpp
@@ -0,0 +1,337 @@
+/*=========================================================================
+ * 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/Pool.hpp>
+#include "impl/NativeWrapper.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache {
+        
+    namespace Generic
+    {
+      //generic<class TKey, class TResult>
+      //ref class Properties;
+
+      generic<class TKey, class TResult>
+      ref class QueryService;
+
+      ref class Cache;
+
+      /// <summary>
+      /// A pool of connections.
+      /// </summary>
+      /// <remarks>
+      /// A pool of connections from a GemFire client to a set of GemFire servers.
+      /// </remarks>
+     // generic<class TKey, class TValue>
+      public ref class Pool sealed
+				: public Generic::Internal::SBWrap<gemfire::Pool>
+      {
+      public:
+
+		/// <summary>
+	    /// Get the name of the pool
+		/// </summary>
+	    property String^ Name
+		{
+		  String^ get( );
+		}
+
+		/// <summary>
+		/// Returns the connection timeout of this pool.
+		/// </summary>
+		property Int32 FreeConnectionTimeout
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the load conditioning interval of this pool.
+		/// </summary>
+		property Int32 LoadConditioningInterval
+		{
+      Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the socket buffer size of this pool.
+		/// </summary>
+    property Int32 SocketBufferSize
+		{
+		  Int32 get( );
+		}
+ 
+		/// <summary>
+		/// Returns the read timeout of this pool.
+		/// </summary>
+    property Int32 ReadTimeout
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the minimum connections for this pool.
+		/// </summary>
+    property Int32 MinConnections
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the maximum connections for this pool.
+		/// </summary>
+		property Int32 MaxConnections
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the Idle connection timeout for this pool.
+		/// </summary>
+    property Int32 IdleTimeout
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the ping interval for this pool.
+		/// </summary>
+		property Int32 PingInterval
+		{
+		  Int32 get( );
+		}
+
+    /// <summary>
+		/// Get the update locator list interval for this pool.
+		/// </summary>
+		property Int32 UpdateLocatorListInterval
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the statistic interval for this pool.
+		/// </summary>
+    property Int32 StatisticInterval
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Get the retry attempts for this pool.
+		/// </summary>
+		property Int32 RetryAttempts
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the true if a server-to-client subscriptions are enabled on this pool.
+		/// </summary>
+		property Boolean SubscriptionEnabled
+		{
+		  Boolean get( );
+		}
+
+        /// <summary>
+		/// Returns the true if a pr-single-hop is set to true on this pool.
+		/// </summary>
+		property Boolean PRSingleHopEnabled
+		{
+		  Boolean get( );
+		}
+
+		/// <summary>
+		/// Returns the subscription redundancy level of this pool.
+		/// </summary>
+		property Int32 SubscriptionRedundancy
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the subscription message tracking timeout of this pool.
+		/// </summary>
+		property Int32 SubscriptionMessageTrackingTimeout
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the subscription ack interval of this pool.
+		/// </summary>
+    property Int32 SubscriptionAckInterval
+		{
+		  Int32 get( );
+		}
+
+		/// <summary>
+		/// Returns the server group of this pool.
+		/// </summary>
+		property String^ ServerGroup
+		{
+		  String^ get( );
+		}
+
+		/// <summary>
+		/// Returns an unmodifiable list of locators
+		/// this pool is using. Each locator is either one
+		/// added explicitly when the pool was created or
+		/// were discovered using the explicit locators.
+		/// </summary>
+		/// <remarks>
+		/// If a pool has no locators then it can not discover servers or locators at runtime.
+		/// </remarks>
+		property array< String^ >^ Locators
+		{
+		  array< String^ >^ get( );
+		}
+
+		/// <summary>
+		/// Returns an unmodifiable list of
+		/// servers this pool is using. These servers were added
+		/// explicitly when the pool was created.
+		property array< String^ >^ Servers
+		{
+		  array< String^ >^ get( );
+		}
+
+		/// <summary>
+		/// Returns the true if ThreadLocalConnections are enabled on this pool.
+		/// </summary>
+		property Boolean ThreadLocalConnections
+		{
+		  Boolean get( );
+		}
+
+		/// <summary>
+		/// Returns <code>true</code> if multiuser authentication is enabled on this pool.
+		/// <summary>
+    property bool MultiuserAuthentication
+    {
+      bool get( );
+    }
+		/// <summary>
+		/// Destroys this pool closing any connections it produced.
+		/// </summary>
+		/// <param name="keepAlive">
+		/// whether the server should keep the durable client's
+		/// subscriptions alive for the timeout period
+		/// </param>
+		/// <exception cref="IllegalStateException">
+		/// if the pool is still in use
+		/// </exception>
+		void Destroy( Boolean keepAlive );
+
+		/// <summary>
+		/// Destroys this pool closing any connections it produced.
+		/// </summary>
+		/// <exception cref="IllegalStateException">
+		/// if the pool is still in use
+		/// </exception>
+		void Destroy( );
+		
+		/// <summary>
+		/// Indicates whether this Pool has been
+		/// destroyed.
+		/// </summary>
+		property Boolean Destroyed
+		{
+		  Boolean get( );
+		}
+
+		/// <summary>
+		/// Returns the QueryService for this Pool.
+		/// </summary>
+		/// <remarks>
+		/// The query operations performed using this QueryService will be executed
+		/// on the servers that are associated with this pool.
+		/// To perform Query operation on the local cache obtain the QueryService
+		/// instance from the Cache.
+		/// </remarks>
+    generic<class TKey, class TResult>
+    QueryService<TKey, TResult>^ GetQueryService();
+
+    void ReleaseThreadLocalConnection();
+
+     /// <summary>  
+     /// Returns the approximate number of pending subscription events maintained at
+     /// server for this durable client pool at the time it (re)connected to the
+     /// server. Server would start dispatching these events to this durable client
+     /// pool when it receives {@link Cache#readyForEvents()} from it.
+     /// <p>
+     /// Durable clients can call this method on reconnect to assess the amount of
+     /// 'stale' data i.e. events accumulated at server while this client was away
+     /// and, importantly, before calling {@link Cache#readyForEvents()}.
+     /// <p>
+     /// Any number of invocations of this method during a single session will
+     /// return the same value.
+     /// <p>
+     /// It may return a zero value if there are no events pending at server for
+     /// this client pool. A negative value returned tells us that no queue was
+     /// available at server for this client pool.
+     /// <p>
+     /// A value -1 indicates that this client pool reconnected to server after its
+     /// 'durable-client-timeout' period elapsed and hence its subscription queue at
+     /// server was removed, possibly causing data loss.
+     /// <p>
+     /// A value -2 indicates that this client pool connected to server for the
+     /// first time.
+     /// 
+     /// @return int The number of subscription events maintained at server for this
+     ///         durable client pool at the time this pool (re)connected. A negative
+     ///         value indicates no queue was found for this client pool.
+     /// @throws IllegalStateException
+     ///           If called by a non-durable client or if invoked any time after
+     ///           invocation of {@link Cache#readyForEvents()}.
+     /// @since 8.1
+     ///
+     /// </summary>
+      property Int32 PendingEventCount
+      {
+        Int32 get( );
+      }
+
+		  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 Pool^ Create( gemfire::Pool* nativeptr )
+      {
+        return ( nativeptr != nullptr ?
+          gcnew Pool( nativeptr ) : nullptr );
+      }
+
+      private:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline Pool( gemfire::Pool* nativeptr )
+          : SBWrap( nativeptr ) { }
+      };
+
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/PoolFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/PoolFactory.cpp b/src/clicache/src/PoolFactory.cpp
new file mode 100644
index 0000000..803e193
--- /dev/null
+++ b/src/clicache/src/PoolFactory.cpp
@@ -0,0 +1,283 @@
+/*=========================================================================
+ * 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_includes.hpp"
+#include "Pool.hpp"
+#include "PoolFactory.hpp"
+
+#include "impl/ManagedString.hpp"
+#include "ExceptionTypes.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+
+      //generic<class TKey, class TValue>
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetFreeConnectionTimeout( Int32 connectionTimeout )
+		  {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setFreeConnectionTimeout( connectionTimeout );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetLoadConditioningInterval( Int32 loadConditioningInterval )
+		  {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setLoadConditioningInterval( loadConditioningInterval );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetSocketBufferSize( Int32 bufferSize )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setSocketBufferSize( bufferSize );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetReadTimeout( Int32 timeout )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setReadTimeout( timeout );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetMinConnections( Int32 minConnections )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setMinConnections( minConnections );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetMaxConnections( Int32 maxConnections )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setMaxConnections( maxConnections );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetIdleTimeout( Int32 idleTimeout )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setIdleTimeout( idleTimeout );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetRetryAttempts( Int32 retryAttempts )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setRetryAttempts( retryAttempts );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetPingInterval( Int32 pingInterval )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setPingInterval( pingInterval );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetUpdateLocatorListInterval( Int32 updateLocatorListInterval )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setUpdateLocatorListInterval( updateLocatorListInterval );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetStatisticInterval( Int32 statisticInterval )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setStatisticInterval( statisticInterval );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetServerGroup( String^ group )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+        ManagedString mg_servergroup( group );
+			  NativePtr->setServerGroup( mg_servergroup.CharPtr );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::AddLocator( String^ host, Int32 port )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+        ManagedString mg_host( host );
+			  NativePtr->addLocator( mg_host.CharPtr, port );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::AddServer( String^ host, Int32 port )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  ManagedString mg_host( host );
+			  NativePtr->addServer( mg_host.CharPtr, port );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetSubscriptionEnabled( Boolean enabled )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setSubscriptionEnabled( enabled );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+          PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetPRSingleHopEnabled( Boolean enabled )
+          {
+            _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+              NativePtr->setPRSingleHopEnabled(enabled);
+
+             _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+               return this;
+          }
+
+          //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetSubscriptionRedundancy( Int32 redundancy )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setSubscriptionRedundancy( redundancy );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetSubscriptionMessageTrackingTimeout( Int32 messageTrackingTimeout )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setSubscriptionMessageTrackingTimeout( messageTrackingTimeout );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetSubscriptionAckInterval( Int32 ackInterval )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->setSubscriptionAckInterval( ackInterval );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetThreadLocalConnections( Boolean enabled )
+      {
+			  _GF_MG_EXCEPTION_TRY2
+
+			  NativePtr->setThreadLocalConnections( enabled );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2
+          return this;
+	  }
+      //generic<class TKey, class TValue>
+      PoolFactory^ PoolFactory/*<TKey, TValue>*/::SetMultiuserAuthentication( bool multiuserAuthentication )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+          NativePtr->setMultiuserAuthentication( multiuserAuthentication );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+	   }
+
+      //generic<class TKey, class TValue>
+		  PoolFactory^ PoolFactory/*<TKey, TValue>*/::Reset()
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+			  NativePtr->reset( );
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+          return this;
+		  }
+
+      //generic<class TKey, class TValue>
+		  Pool/*<TKey, TValue>*/^ PoolFactory/*<TKey, TValue>*/::Create( String^ name )
+      {
+			  _GF_MG_EXCEPTION_TRY2/* due to auto replace */
+
+        ManagedString mg_name( name );
+        gemfire::PoolPtr & pool = NativePtr->create(mg_name.CharPtr);
+        return Pool/*<TKey, TValue>*/::Create(pool.ptr());
+
+			  _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+		  }
+    }
+  }
+}
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/PoolFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/PoolFactory.hpp b/src/clicache/src/PoolFactory.hpp
new file mode 100644
index 0000000..abfbe05
--- /dev/null
+++ b/src/clicache/src/PoolFactory.hpp
@@ -0,0 +1,412 @@
+/*=========================================================================
+ * 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/PoolFactory.hpp>
+//#include "impl/NativeWrapper.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+     // generic<class TKey, class TValue>
+      ref class Pool;
+
+      /// <summary>
+      /// This interface provides for the configuration and creation of instances of Pool.
+      /// </summary>
+     // generic<class TKey, class TValue>
+      public ref class PoolFactory sealed
+        : public Internal::SBWrap<gemfire::PoolFactory>
+      {
+      public:
+
+		  /// <summary>
+		  /// Sets the free connection timeout for this pool.
+		  /// </summary>
+		  /// <remarks>
+		  /// If the pool has a max connections setting, operations will block
+		  /// if all of the connections are in use. The free connection timeout
+		  /// specifies how long those operations will block waiting for
+		  /// a free connection before receiving an AllConnectionsInUseException.
+		  /// If max connections is not set this setting has no effect.
+          /// </remarks>
+		  /// <param>
+		  /// connectionTimeout the connection timeout in milliseconds
+		  /// </param>
+		  /// <exception>
+		  /// IllegalArgumentException if connectionTimeout 
+		  /// is less than or equal to 0.
+		  /// </exception>
+		  PoolFactory^ SetFreeConnectionTimeout( Int32 connectionTimeout );
+
+		  /// <summary>
+		  /// Sets the load conditioning interval for this pool.
+		  /// </summary>
+		  /// <remarks>
+		  /// This interval controls how frequently the pool will check to see if
+		  /// a connection to a given server should be moved to a different
+		  /// server to improve the load balance.
+		  /// </remarks>
+		  /// <param>
+		  /// loadConditioningInterval the connection lifetime in milliseconds
+		  /// A value of -1 disables load conditioning.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if connectionLifetime
+		  /// is less than -1.
+		  /// </exception>
+      PoolFactory^ SetLoadConditioningInterval( Int32 loadConditioningInterval );
+
+		  /// <summary>
+		  /// Sets the socket buffer size for each connection made in this pool.
+		  /// </summary>
+		  /// <remarks>
+		  /// Large messages can be received and sent faster when this buffer is larger.
+		  /// Larger buffers also optimize the rate at which servers can send events
+		  /// for client subscriptions.
+		  /// </remarks>
+		  /// <param>
+		  /// bufferSize the size of the socket buffers used for reading and
+		  /// writing on each connection in this pool.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if bufferSize
+		  /// is less than or equal to 0.
+		  /// </exception>
+		  PoolFactory^ SetSocketBufferSize( Int32 bufferSize );
+
+		  /// <summary>
+		  /// Sets the number of milliseconds to wait for a response from a server before
+		  /// timing out the operation and trying another server (if any are available).
+		  /// </summary>
+		  /// <param>
+		  /// timeout number of milliseconds to wait for a response from a server
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if timeout
+		  /// is less than or equal to 0.
+		  /// </exception>
+		  PoolFactory^ SetReadTimeout( Int32 timeout );
+
+		  /// <summary>
+		  /// Set the minimum number of connections to keep available at all times.
+		  /// </summary>
+		  /// <remarks>
+		  /// When the pool is created, it will create this many connections.
+		  /// If 0 then connections will not be made until an actual operation
+		  /// is done that requires client-to-server communication.
+		  /// </remarks>
+		  /// <param>
+		  /// minConnections the initial number of connections this pool will create.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if minConnections is less than 0.
+		  /// </exception>
+		  PoolFactory^ SetMinConnections( Int32 minConnections );
+
+		  /// <summary>
+		  /// Set the max number of client to server connections that the pool will create.
+		  /// </summary>
+		  /// <remarks>
+		  /// If all of the connections are in use, an operation requiring a client to
+		  /// server connection will block until a connection is available.
+		  /// see setFreeConnectionTimeout(int)
+		  /// </remarks>
+		  /// <param>
+		  /// maxConnections the maximum number of connections in the pool.
+		  /// -1 indicates that there is no maximum number of connections.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if maxConnections is less than minConnections.
+		  /// </exception>
+		  PoolFactory^ SetMaxConnections( Int32 maxConnections );
+
+		  /// <summary>
+		  /// Set the amount of time a connection can be idle before expiring the connection.
+		  /// </summary>
+		  /// <remarks>
+		  /// If the pool size is greater than the minimum specified, connections which have
+		  /// been idle for longer than the idleTimeout will be closed.
+		  /// </remarks>
+		  /// <param>
+		  /// idleTimeout The amount of time in milliseconds that an idle connection
+		  /// should live before expiring. -1 indicates that connections should never expire.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if idleTimout is less than 0.
+		  /// </exception>
+		  PoolFactory^ SetIdleTimeout( Int32 idleTimeout );
+
+		  /// <summary>
+		  /// Set the number of times to retry a request after timeout/exception.
+		  /// </summary>
+		  /// <param>
+		  /// retryAttempts The number of times to retry a request
+		  /// after timeout/exception. -1 indicates that a request should be
+		  /// tried against every available server before failing.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if idleTimout is less than 0.
+		  /// </exception>
+		  PoolFactory^ SetRetryAttempts( Int32 retryAttempts );
+
+		  /// <summary>
+		  /// Set how often to ping servers to verify that they are still alive.
+		  /// </summary>
+		  /// <remarks>
+		  /// Each server will be sent a ping every pingInterval if there has not
+		  /// been any other communication with the server.
+		  /// These pings are used by the server to monitor the health of
+		  /// the client. Make sure that the pingInterval is less than the
+		  /// maximum time between pings allowed by the bridge server.
+		  /// see in CacheServer: setMaximumTimeBetweenPings(int)
+		  /// </remarks>
+		  /// <param>
+		  /// pingInterval The amount of time in milliseconds between pings.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if pingInterval is less than 0.
+		  /// </exception>
+		  PoolFactory^ SetPingInterval( Int32 pingInterval );
+
+      /// <summary>
+		  /// Set how often to update locator list from locator
+		  /// </summary>
+		  /// <param>
+		  /// updateLocatorListInterval The amount of time in milliseconds between
+      /// updating locator list. If its set to 0 then client will not update
+      /// the locator list.
+		  /// </param>
+		  /// <returns>
+      /// a instance of <c>CacheFactory</c> 
+      /// </returns>
+		  PoolFactory^ SetUpdateLocatorListInterval( Int32 updateLocatorListInterval );
+
+		  /// <summary>
+		  /// Set how often to send client statistics to the server.
+		  /// </summary>
+		  /// <remarks>
+		  /// Doing this allows gfmon to monitor clients.
+		  /// A value of -1 disables the sending of client statistics
+		  /// to the server.
+          /// </remarks>
+		  /// <param>
+		  /// statisticInterval The amount of time in milliseconds between
+		  /// sends of client statistics to the server.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if statisticInterval
+		  /// is less than -1.
+		  /// </exception>
+      PoolFactory^ SetStatisticInterval( Int32 statisticInterval);
+
+		  /// <summary>
+		  /// Configures the group that all servers this pool connects to must belong to.
+		  /// </summary>
+		  /// <param>
+		  /// group the server group that this pool will connect to.
+		  /// If null or "" then all servers will be connected to.
+		  /// </param>
+      PoolFactory^ SetServerGroup( String^ group );
+
+		  /// <summary>
+		  /// Add a locator, given its host and port, to this factory.
+		  /// </summary>
+		  /// <remarks>
+		  /// The locator must be a server locator and will be used to discover other running
+		  /// bridge servers and locators.
+		  /// </remarks>
+		  /// <param>
+		  /// host the host name or ip address that the locator is listening on.
+		  /// </param>
+		  /// <param>
+		  /// port the port that the locator is listening on
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if host is an unknown host
+		  /// or if port is outside the valid range of [1..65535] inclusive.
+		  /// </exception>
+		  /// <exception>
+		  /// throws IllegalStateException if a locator has already been added to this factory.
+		  /// </exception>
+		  PoolFactory^ AddLocator( String^ host, Int32 port );
+
+		  /// <summary>
+		  /// Add a server, given its host and port, to this factory.
+		  /// </summary>
+		  /// <remarks>
+		  /// The server must be a bridge server and this client will
+		  /// directly connect to without consulting a server locator.
+		  /// </remarks>
+		  /// <param>
+		  /// host the host name or ip address that the server is listening on.
+		  /// </param>
+		  /// <param>
+		  /// port the port that the server is listening on
+		  /// </param>
+          /// <exception>
+		  /// throws IllegalArgumentException if host is an unknown host
+		  /// or if port is outside the valid range of [1..65535] inclusive.
+		  /// </exception>
+		  /// <exception>
+		  /// throws IllegalStateException if a server has already been added to this factory.
+		  /// </exception>
+      PoolFactory^ AddServer( String^ host, Int32 port );
+
+		  /// <summary>
+		  /// Enable subscriptions.
+		  /// </summary>
+		  /// <remarks>
+		  /// If set to true then the created pool will have server-to-client
+		  /// subscriptions enabled. If set to false then all Subscription*
+		  /// attributes are ignored at create time.
+		  /// </remarks>
+		  PoolFactory^ SetSubscriptionEnabled( Boolean enabled );
+
+           /// <summary>
+		  /// By default SetPRSingleHopEnabled is true.
+		  /// </summary>
+		  /// <remarks>
+		  /// The client is aware of location of partitions on servers hosting
+          /// Using this information, the client routes the client cache operations
+		  /// directly to the server which is hosting the required partition for the
+		  /// cache operation. 
+          /// If SetPRSingleHopEnabled is false the client can do an extra hop on servers
+          /// to go to the required partition for that cache operation.
+          /// The SetPRSingleHopEnabled avoids extra hops only for following cache operations :
+          /// put, get & destroy operations.
+		  /// </remarks>
+		  PoolFactory^ SetPRSingleHopEnabled( Boolean enabled );
+
+		  /// <summary>
+		  /// Sets the redundancy level for this pools server-to-client subscriptions.
+		  /// </summary>
+		  /// <remarks>
+		  /// If 0 then no redundant copies will be kept on the servers.
+		  /// Otherwise an effort will be made to maintain the requested number of
+		  /// copies of the server-to-client subscriptions. At most one copy per server will
+		  /// be made up to the requested level.
+		  /// </remarks>
+		  /// <param>
+		  /// redundancy the number of redundant servers for this client's subscriptions.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if redundancyLevel is less than -1.
+		  /// </exception>
+		  PoolFactory^ SetSubscriptionRedundancy( Int32 redundancy );
+
+		  /// <summary>
+		  /// Sets the messageTrackingTimeout attribute which is the time-to-live period,
+		  /// in milliseconds, for subscription events the client has received from the server.
+		  /// </summary>
+		  /// <remarks>
+		  /// It's used to minimize duplicate events. Entries that have not been modified
+		  /// for this amount of time are expired from the list.
+		  /// </remarks>
+		  /// <param>
+		  /// messageTrackingTimeout number of milliseconds to set the timeout to.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if messageTrackingTimeout is less than or equal to 0.
+		  /// </exception>
+		  PoolFactory^ SetSubscriptionMessageTrackingTimeout( Int32 messageTrackingTimeout );
+
+		  /// <summary>
+		  /// Sets the is the interval in milliseconds to wait before sending
+		  /// acknowledgements to the bridge server for events received from the server subscriptions.
+		  /// </summary>
+		  /// <param>
+		  /// ackInterval number of milliseconds to wait before sending event acknowledgements.
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalArgumentException if ackInterval is less than or equal to 0.
+		  /// </exception>
+		  PoolFactory^ SetSubscriptionAckInterval( Int32 ackInterval );
+
+		  /// <summary>
+		  /// Enable ThreadLocalConnection.
+		  /// </summary>
+		  /// <remarks>
+		  /// Sets the thread local connections policy for this pool.
+		  /// If true then any time a thread goes to use a connection
+		  /// from this pool it will check a thread local cache and see if it already
+		  /// has a connection in it. If so it will use it. If not it will get one from
+		  /// this pool and cache it in the thread local. This gets rid of thread contention
+		  /// for the connections but increases the number of connections the servers see.
+		  /// If false then connections are returned to the pool as soon
+		  /// as the operation being done with the connection completes. This allows
+		  /// connections to be shared amonst multiple threads keeping the number of
+		  /// connections down.
+		  /// </remarks>
+		  PoolFactory^ SetThreadLocalConnections( Boolean enabled );
+
+      /// <summary>
+		  /// Sets whether pool is in multiuser mode
+      /// If its in multiuser mode then app needs to get instance of cache from pool.getCache("creds"), to do the operations on cache.
+		  /// </summary>
+		  /// <param>
+		  /// multiuserAuthentication should be true/false. Default value is false;
+		  /// </param>
+      PoolFactory^ SetMultiuserAuthentication( bool multiuserAuthentication );
+
+		  /// <summary>
+		  /// Resets the configuration of this factory to its defaults.
+		  /// </summary>
+		  PoolFactory^ Reset();
+
+		  /// <summary>
+		  /// Create a new Pool for connecting a client to a set of GemFire Cache Servers.
+		  /// using this factory's settings for attributes.
+		  /// </summary>
+		  /// <param>
+		  /// name the name of the pool, used when connecting regions to it
+		  /// </param>
+		  /// <exception>
+		  /// throws IllegalStateException if a pool with name already exists
+		  /// throws IllegalStateException if a locator or server has not been added.
+                  /// </exception>
+		  Pool/*<TKey, TValue>*/^ Create( String^ name );
+
+    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 PoolFactory/*<TKey, TValue>*/^ Create( gemfire::PoolFactory* nativeptr )
+      {
+        return ( nativeptr != nullptr ?
+          gcnew PoolFactory( nativeptr ) : nullptr );
+      }
+
+	  private:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline PoolFactory( gemfire::PoolFactory* nativeptr )
+          : SBWrap( nativeptr ) { }
+      };
+
+    }
+  }
+}
+
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/PoolManager.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/PoolManager.cpp b/src/clicache/src/PoolManager.cpp
new file mode 100644
index 0000000..8ae7704
--- /dev/null
+++ b/src/clicache/src/PoolManager.cpp
@@ -0,0 +1,77 @@
+/*=========================================================================
+ * 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_includes.hpp"
+#include "Region.hpp"
+#include "Pool.hpp"
+#include "PoolManager.hpp"
+#include "PoolFactory.hpp"
+#include "CacheableString.hpp"
+#include "impl/SafeConvert.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache { namespace Generic
+    {
+      //generic<class TKey, class TValue>
+      PoolFactory/*<TKey, TValue>*/^ PoolManager/*<TKey, TValue>*/::CreateFactory()
+      {
+        return PoolFactory/*<TKey, TValue>*/::Create(gemfire::PoolManager::createFactory().ptr());
+      }
+
+      //generic<class TKey, class TValue>
+      const Dictionary<String^, Pool/*<TKey, TValue>*/^>^ PoolManager/*<TKey, TValue>*/::GetAll()
+      {
+        gemfire::HashMapOfPools pools = gemfire::PoolManager::getAll();
+        Dictionary<String^, Pool/*<TKey, TValue>*/^>^ result = gcnew Dictionary<String^, Pool/*<TKey, TValue>*/^>();
+        for (gemfire::HashMapOfPools::Iterator iter = pools.begin(); iter != pools.end(); ++iter)
+        {
+          String^ key = CacheableString::GetString(iter.first().ptr());
+          Pool/*<TKey, TValue>*/^ val = Pool/*<TKey, TValue>*/::Create(iter.second().ptr());
+          result->Add(key, val);
+        }
+        return result;
+      }
+
+      //generic<class TKey, class TValue>
+      Pool/*<TKey, TValue>*/^ PoolManager/*<TKey, TValue>*/::Find(String^ name)
+      {
+        ManagedString mg_name( name );
+        gemfire::PoolPtr pool = gemfire::PoolManager::find(mg_name.CharPtr);
+        return Pool/*<TKey, TValue>*/::Create(pool.ptr());
+      }
+
+      //generic <class TKey, class TValue>
+      Pool/*<TKey, TValue>*/^ PoolManager/*<TKey, TValue>*/::Find(Generic::Region<Object^, Object^>^ region)
+      {
+        //return Pool::Create(gemfire::PoolManager::find(gemfire::RegionPtr(GetNativePtr<gemfire::Region>(region))).ptr());
+        return Pool/*<TKey, TValue>*/::Create(gemfire::PoolManager::find(gemfire::RegionPtr(region->_NativePtr)).ptr());
+      }
+
+      //generic<class TKey, class TValue>
+      void PoolManager/*<TKey, TValue>*/::Close(Boolean KeepAlive)
+      {
+        gemfire::PoolManager::close(KeepAlive);
+      }
+
+      //generic<class TKey, class TValue>
+      void PoolManager/*<TKey, TValue>*/::Close()
+      {
+        gemfire::PoolManager::close();
+      }
+    }
+  }
+}
+
+ } //namespace 

http://git-wip-us.apache.org/repos/asf/geode/blob/2d4a7ecd/src/clicache/src/PoolManager.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/PoolManager.hpp b/src/clicache/src/PoolManager.hpp
new file mode 100644
index 0000000..13f623e
--- /dev/null
+++ b/src/clicache/src/PoolManager.hpp
@@ -0,0 +1,71 @@
+/*=========================================================================
+ * 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/PoolManager.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 TKey, class TValue>
+      ref class PoolFactory;
+
+      /// <summary>
+      /// This interface provides for the configuration and creation of instances of PoolFactory.
+      /// </summary>
+     // generic<class TKey, class TValue>
+      public ref class PoolManager STATICCLASS
+      {
+      public:
+
+        /// <summary>
+        /// Creates a new PoolFactory which is used to configure and create Pools.
+        /// </summary>
+        static PoolFactory/*<TKey, TValue>*/^ CreateFactory();
+
+        /// <summary>
+        /// Returns a map containing all the pools in this manager.
+        /// The keys are pool names and the values are Pool instances.
+        /// </summary>
+        static const Dictionary<String^, Pool/*<TKey, TValue>*/^>^ GetAll();
+
+        /// <summary>
+        /// Find by name an existing connection pool.
+        /// </summary>
+        static Pool/*<TKey, TValue>*/^ Find(String^ name);
+
+        /// <summary>
+        /// Find the pool used by the given region.
+        /// </summary>
+        static Pool/*<TKey, TValue>*/^ Find(Generic::Region<Object^, Object^>^ region);
+
+        /// <summary>
+        /// Destroys all created pools.
+        /// </summary>
+        static void Close(Boolean KeepAlive);
+
+        /// <summary>
+        /// Destroys all created pools.
+        /// </summary>
+        static void Close();
+      };
+    }
+  }
+}
+
+ } //namespace 


Mime
View raw message