geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject [12/51] [partial] incubator-geode git commit: Add source for geode c++ and .net clients
Date Thu, 19 May 2016 15:14:19 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionAttributesM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionAttributesM.hpp b/geode-client-native/src/clicache/RegionAttributesM.hpp
new file mode 100644
index 0000000..9300215
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionAttributesM.hpp
@@ -0,0 +1,504 @@
+/*=========================================================================
+ * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+ * This product is protected by U.S. and international copyright
+ * and intellectual property laws. Pivotal products are covered by
+ * more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/RegionAttributes.hpp"
+#include "impl/NativeWrapper.hpp"
+#include "IGFSerializable.hpp"
+#include "ExpirationActionM.hpp"
+#include "ScopeTypeM.hpp"
+#include "DiskPolicyTypeM.hpp"
+#include "GemFireClassIdsM.hpp"
+
+#include "ICacheLoader.hpp"
+#include "ICacheWriter.hpp"
+#include "ICacheListener.hpp"
+#include "IPartitionResolver.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      ref class Properties;
+      //interface class ICacheLoader;
+      //interface class ICacheWriter;
+      //interface class ICacheListener;
+      //interface class IPartitionResolver;
+
+      /// <summary>
+      /// Defines attributes for configuring a region.
+      /// </summary>
+      /// <remarks>
+      /// These are
+      /// <c>ICacheListener</c>, <c>ICacheLoader</c>, <c>ICacheWriter</c>,
+      /// scope, mirroring, and expiration attributes
+      /// for the region itself; expiration attributes for the region entries;
+      /// and whether statistics are enabled for the region and its entries.
+      ///
+      /// To create an instance of this interface, use
+      /// <see cref="AttributesFactory.CreateRegionAttributes" />.
+      ///
+      /// For compatibility rules and default values, see <see cref="AttributesFactory" />.
+      /// <para>
+      /// Note that the <c>RegionAttributes</c> are not distributed with the region.
+      /// </para>
+      /// </remarks>
+      /// <seealso cref="AttributesFactory" />
+      /// <seealso cref="AttributesMutator" />
+      /// <seealso cref="Region.Attributes" />
+      [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class RegionAttributes sealed
+        : public Internal::SBWrap<gemfire::RegionAttributes>, public IGFSerializable
+      {
+      public:
+
+        /// <summary>
+        /// Gets the cache loader for the region.
+        /// </summary>
+        /// <returns>
+        /// region's <c>ICacheLoader</c> or null if none
+        /// </returns>
+        property ICacheLoader^ CacheLoader
+        {
+          ICacheLoader^ get( );
+        }
+
+        /// <summary>
+        /// Gets the cache writer for the region.
+        /// </summary>
+        /// <returns>
+        /// region's <c>ICacheWriter</c> or null if none
+        /// </returns>
+        property ICacheWriter^ CacheWriter
+        {
+          ICacheWriter^ get( );
+        }
+
+        /// <summary>
+        /// Gets the cache listener for the region.
+        /// </summary>
+        /// <returns>
+        /// region's <c>ICacheListener</c> or null if none
+        /// </returns>
+        property ICacheListener^ CacheListener
+        {
+          ICacheListener^ get( );
+        }
+
+        /// <summary>
+        /// Gets the partition resolver for the region.
+        /// </summary>
+        /// <returns>
+        /// region's <c>IPartitionResolver</c> or null if none
+        /// </returns>
+        property IPartitionResolver^ PartitionResolver
+        {
+          IPartitionResolver^ get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>timeToLive</c> value for the region as a whole.
+        /// </summary>
+        /// <returns>the timeToLive duration for this region, in seconds</returns>
+        property int32_t RegionTimeToLive
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>timeToLive</c> expiration action for the region as a whole.
+        /// </summary>
+        /// <returns>the timeToLive action for this region</returns>
+        property ExpirationAction RegionTimeToLiveAction
+        {
+          ExpirationAction get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>idleTimeout</c> value for the region as a whole.
+        /// </summary>
+        /// <returns>the IdleTimeout duration for this region, in seconds</returns>
+        property int32_t RegionIdleTimeout
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>idleTimeout</c> expiration action for the region as a whole.
+        /// </summary>
+        /// <returns>the idleTimeout action for this region</returns>
+        property ExpirationAction RegionIdleTimeoutAction
+        {
+          ExpirationAction get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>timeToLive</c> value for entries in this region.
+        /// </summary>
+        /// <returns>the timeToLive duration for entries in this region, in seconds</returns>
+        property int32_t EntryTimeToLive
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>timeToLive</c> expiration action for entries in this region.
+        /// </summary>
+        /// <returns>the timeToLive action for entries in this region</returns>
+        property ExpirationAction EntryTimeToLiveAction
+        {
+          ExpirationAction get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>idleTimeout</c> value for entries in this region.
+        /// </summary>
+        /// <returns>the idleTimeout duration for entries in this region, in seconds</returns>
+        property int32_t EntryIdleTimeout
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Gets the <c>idleTimeout</c> expiration action for entries in this region.
+        /// </summary>
+        /// <returns>the idleTimeout action for entries in this region</returns>
+        property ExpirationAction EntryIdleTimeoutAction
+        {
+          ExpirationAction get( );
+        }
+
+        /// <summary>
+        /// Returns the scope of the region.
+        /// </summary>
+        /// <returns>the region's scope</returns>
+        property ScopeType Scope
+        {
+          ScopeType get( );
+        }
+
+        /// <summary>
+        /// If true, this region will store data in the current process.
+        /// </summary>
+        /// <returns>true if caching is enabled</returns>
+        property bool CachingEnabled
+        {
+          bool get( );
+        }
+
+
+        // MAP ATTRIBUTES
+
+        /// <summary>
+        /// Returns the initial capacity of the entry's local cache.
+        /// </summary>
+        /// <returns>the initial capacity</returns>
+        property int32_t InitialCapacity
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Returns the load factor of the entry's local cache.
+        /// </summary>
+        /// <returns>the load factor</returns>
+        property Single LoadFactor
+        {
+          Single get( );
+        }
+
+        /// <summary>
+        /// Returns the concurrency level of the entry's local cache.
+        /// </summary>
+        /// <returns>the concurrency level</returns>
+        /// <seealso cref="AttributesFactory" />
+        property int32_t ConcurrencyLevel
+        {
+          int32_t get( );
+        }
+
+        /// <summary>
+        /// Returns the maximum number of entries this cache will hold before
+        /// using LRU eviction. 
+        /// </summary>
+        /// <returns>the maximum LRU size, or 0 for no limit</returns>
+        property uint32_t LruEntriesLimit
+        {
+          uint32_t get( );
+        }
+
+        /// <summary>
+        /// Returns the disk policy type of the region.
+        /// </summary>
+        /// <returns>the disk policy type, default is null</returns>
+        property DiskPolicyType DiskPolicy
+        {
+          DiskPolicyType get( );
+        }
+
+        /// <summary>
+        /// Returns the ExpirationAction used for LRU Eviction, default is LOCAL_DESTROY.
+        /// </summary>
+        /// <returns>the LRU eviction action</returns>
+        property ExpirationAction LruEvictionAction
+        {
+          ExpirationAction get( );
+        }
+
+        /// <summary>
+        /// Returns the path of the library from which
+        /// the factory function will be invoked on a cache server.
+        /// </summary>
+        /// <returns>the CacheLoader library path</returns>
+        property String^ CacheLoaderLibrary
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Rreturns the symbol name of the factory function from which
+        /// the loader will be created on a cache server.
+        /// </summary>
+        /// <returns>the CacheLoader factory function name</returns>
+        property String^ CacheLoaderFactory
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the path of the library from which
+        /// the factory function will be invoked on a cache server.
+        /// </summary>
+        /// <returns>the CacheListener library path</returns>
+        property String^ CacheListenerLibrary
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the path of the library from which
+        /// the factory function will be invoked on a cache server.
+        /// </summary>
+        /// <returns>the PartitionResolver library path</returns>
+        property String^ PartitionResolverLibrary
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the symbol name of the factory function from which
+        /// the loader will be created on a cache server.
+        /// </summary>
+        /// <returns>the CacheListener factory function name</returns>
+        property String^ CacheListenerFactory
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the symbol name of the factory function from which
+        /// the loader will be created on a cache server.
+        /// </summary>
+        /// <returns>the PartitionResolver factory function name</returns>
+        property String^ PartitionResolverFactory
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the path of the library from which
+        /// the factory function will be invoked on a cache server.
+        /// </summary>
+        /// <returns>the CacheWriter library path</returns>
+        property String^ CacheWriterLibrary
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the symbol name of the factory function from which
+        /// the loader will be created on a cache server.
+        /// </summary>
+        /// <returns>the CacheWriter factory function name</returns>
+        property String^ CacheWriterFactory
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// True if all the attributes are equal to those of <c>other</c>.
+        /// </summary>
+        /// <param name="other">attribute object to compare</param>
+        /// <returns>true if equal</returns>
+        bool Equals( RegionAttributes^ other );
+
+        /// <summary>
+        /// True if all the attributes are equal to those of <c>other</c>.
+        /// </summary>
+        /// <param name="other">attribute object to compare</param>
+        /// <returns>true if equal</returns>
+        virtual bool Equals( Object^ other ) override;
+
+        /// <summary>
+        /// Throws IllegalStateException if the attributes are not suited for serialization
+        /// such as those that have a cache callback (listener, loader, or writer) set
+        /// directly instead of providing the library path and factory function.
+        /// </summary>
+        /// <exception cref="IllegalStateException">if the attributes cannot be serialized</exception>
+        void ValidateSerializableAttributes( );
+
+        /// <summary>
+        /// This method returns the list of endpoints (servername:portnumber) separated by commas.
+        /// </summary>
+        /// <returns>list of endpoints</returns>
+        property String^ Endpoints
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// This method returns the name of the attached pool.
+        /// </summary>
+        /// <returns>pool name</returns>
+        property String^ PoolName
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// True if client notification is enabled.
+        /// </summary>
+        /// <returns>true if enabled</returns>
+        property bool ClientNotificationEnabled
+        {
+          bool get( );
+        }
+        /// <summary>
+        /// True if cloning is enabled for in case of delta.
+        /// </summary>
+        /// <returns>true if enabled</returns>
+
+        property bool CloningEnabled 
+        {
+          bool get( );
+        }
+
+        /// <summary>
+        /// Returns the path of the library from which
+        /// the factory function will be invoked on a cache server.
+        /// </summary>
+        /// <returns>the PersistenceManager library path</returns>
+        property String^ PersistenceLibrary
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the symbol name of the factory function from which
+        /// the persistence manager will be created on a cache server.
+        /// </summary>
+        /// <returns>the PersistenceManager factory function name</returns>
+        property String^ PersistenceFactory
+        {
+          String^ get( );
+        }
+
+        /// <summary>
+        /// Returns the properties set for persistence.
+        /// </summary>
+        /// <returns>properties for the PersistenceManager</returns>
+        property Properties^ PersistenceProperties
+        {
+          Properties^ get( );
+        }
+
+        /// <summary>
+        /// Returns the concurrency check enabled flag of the region
+        /// </summary>
+        /// <returns>the concurrency check enabled flag</returns>
+        /// <seealso cref="AttributesFactory" />
+        property bool ConcurrencyChecksEnabled
+        {
+          bool get( );
+        }
+
+        /// <summary>
+        /// Serializes this Properties object.
+        /// </summary>
+        /// <param name="output">the DataOutput stream to use for serialization</param>
+        virtual void ToData( DataOutput^ output );
+
+        /// <summary>
+        /// Deserializes this Properties object.
+        /// </summary>
+        /// <param name="input">the DataInput stream to use for reading data</param>
+        /// <returns>the deserialized Properties object</returns>
+        virtual IGFSerializable^ FromData( DataInput^ input );
+
+        /// <summary>
+        /// return the size of this object in bytes
+        /// </summary>
+        virtual property uint32_t ObjectSize
+        {
+          virtual uint32_t get( )
+          {
+            return 0;  //don't care
+          }
+        }
+
+        /// <summary>
+        /// Returns the classId of this class for serialization.
+        /// </summary>
+        /// <returns>classId of the Properties class</returns>
+        /// <seealso cref="IGFSerializable.ClassId" />
+        virtual property uint32_t ClassId
+        {
+          inline virtual uint32_t get( )
+          {
+            return GemFireClassIds::RegionAttributes;
+          }
+        }
+
+
+      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 RegionAttributes^ Create( gemfire::RegionAttributes* nativeptr )
+        {
+          return ( nativeptr != nullptr ?
+            gcnew RegionAttributes( nativeptr ) : nullptr );
+        }
+
+
+      private:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline RegionAttributes( gemfire::RegionAttributes* nativeptr )
+          : SBWrap( nativeptr ) { }
+      };
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionEntryM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionEntryM.cpp b/geode-client-native/src/clicache/RegionEntryM.cpp
new file mode 100644
index 0000000..1bd6fa1
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionEntryM.cpp
@@ -0,0 +1,61 @@
+/*=========================================================================
+ * 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 "RegionEntryM.hpp"
+#include "RegionM.hpp"
+#include "CacheStatisticsM.hpp"
+#include "impl/SafeConvert.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      GemStone::GemFire::Cache::ICacheableKey^ RegionEntry::Key::get( )
+      {
+        gemfire::CacheableKeyPtr& nativeptr( NativePtr->getKey( ) );
+
+        return SafeUMKeyConvert( nativeptr.ptr( ) );
+      }
+
+      IGFSerializable^ RegionEntry::Value::get( )
+      {
+        gemfire::CacheablePtr& nativeptr( NativePtr->getValue( ) );
+
+        return SafeUMSerializableConvert( nativeptr.ptr( ) );
+      }
+
+      GemStone::GemFire::Cache::Region^ RegionEntry::Region::get( )
+      {
+        gemfire::RegionPtr rptr;
+
+        NativePtr->getRegion( rptr );
+        return GemStone::GemFire::Cache::Region::Create( rptr.ptr( ) );
+      }
+
+      CacheStatistics^ RegionEntry::Statistics::get( )
+      {
+        gemfire::CacheStatisticsPtr nativeptr;
+
+        NativePtr->getStatistics( nativeptr );
+        return CacheStatistics::Create( nativeptr.ptr( ) );
+      }
+
+      bool RegionEntry::IsDestroyed::get( )
+      {
+        return NativePtr->isDestroyed( );
+      }
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionEntryM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionEntryM.hpp b/geode-client-native/src/clicache/RegionEntryM.hpp
new file mode 100644
index 0000000..370b922
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionEntryM.hpp
@@ -0,0 +1,172 @@
+/*=========================================================================
+ * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+ * This product is protected by U.S. and international copyright
+ * and intellectual property laws. Pivotal products are covered by
+ * more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/RegionEntry.hpp"
+#include "impl/NativeWrapper.hpp"
+#include "ICacheableKey.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      interface class IGFSerializable;
+      ref class Region;
+      ref class CacheStatistics;
+
+      /// <summary>
+      /// An object in a region that represents an <em>entry</em>, that is, a key-value pair.
+      /// </summary>
+      /// <remarks>
+      /// This object's operations are not distributed, do not acquire any locks, and do not affect
+      /// <c>CacheStatistics</c>.
+      ///
+      /// Unless otherwise noted, all of these methods throw a
+      /// <c>CacheClosedException</c> if the cache is closed at the time of
+      /// invocation, or an <c>EntryDestroyedException</c> if the entry has been
+      /// destroyed.
+      ///
+      /// Call <see cref="IsDestroyed" /> to see if an entry has already been destroyed.
+      /// </remarks>
+      [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class RegionEntry sealed
+        : public Internal::SBWrap<gemfire::RegionEntry>
+      {
+      public:
+
+        /// <summary>
+        /// Returns the key for this entry.
+        /// </summary>
+        /// <returns>the key for this entry</returns>
+        /// <exception cref="CacheClosedException">
+        /// if the cache is closed at the time of invocation
+        /// </exception>
+        /// <exception cref="EntryDestroyedException">
+        /// if the entry has been destroyed
+        /// </exception>
+        property GemStone::GemFire::Cache::ICacheableKey^ Key
+        {
+          GemStone::GemFire::Cache::ICacheableKey^ get( );
+        }
+
+        /// <summary>
+        /// Returns the value of this entry in the local cache. Does not invoke
+        /// an <c>ICacheLoader</c>, does not do a netSearch, netLoad, etc.
+        /// </summary>
+        /// <returns>
+        /// the value, or null if this entry is invalid -- see <see cref="IsDestroyed" />
+        /// </returns>
+        /// <exception cref="CacheClosedException">
+        /// if the cache is closed at the time of invocation
+        /// </exception>
+        /// <exception cref="EntryDestroyedException">
+        /// if the entry has been destroyed
+        /// </exception>
+        property IGFSerializable^ Value
+        {
+          IGFSerializable^ get( );
+        }
+
+        /// <summary>
+        /// Returns the region that contains this entry.
+        /// </summary>
+        /// <returns>the region that contains this entry</returns>
+        /// <exception cref="CacheClosedException">
+        /// if the cache is closed at the time of invocation
+        /// </exception>
+        /// <exception cref="EntryDestroyedException">
+        /// if the entry has been destroyed
+        /// </exception>
+        property Region^ Region
+        {
+          GemStone::GemFire::Cache::Region^ get( );
+        }
+
+        /// <summary>
+        /// Returns the statistics for this entry.
+        /// </summary>
+        /// <returns>the CacheStatistics for this entry</returns>
+        /// <exception cref="StatisticsDisabledException">
+        /// if statistics have been disabled for this region
+        /// </exception>
+        property CacheStatistics^ Statistics
+        {
+          CacheStatistics^ get( );
+        }
+
+        ///// <summary>
+        ///// Returns the user attribute for this entry in the local cache.
+        ///// </summary>
+        ///// <returns>the user attribute for this entry</returns>
+        ////Object^ GetUserAttribute( );
+
+        ///// <summary>
+        ///// Sets the user attribute for this entry. Does not distribute the user
+        ///// attribute to other caches.
+        ///// </summary>
+        ///// <param name="uptr">a pointer to the user attribute for this entry</param>
+        ///// <returns>
+        ///// the previous user attribute or null if no user attributes have been
+        ///// set for this entry
+        ///// </returns>
+        ////void SetUserAttribute( Object^ uptr );
+
+        /// <summary>
+        /// True if this entry has been destroyed.
+        /// </summary>
+        /// <remarks>
+        /// Does not throw a <c>EntryDestroyedException</c> if this entry
+        /// has been destroyed.
+        /// </remarks>
+        /// <returns>true if this entry has been destroyed</returns>
+        /// <exception cref="CacheClosedException">
+        /// if the cache is closed at the time of invocation
+        /// </exception>
+        property bool IsDestroyed
+        {
+          bool 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 RegionEntry^ Create( gemfire::RegionEntry* nativeptr )
+        {
+          return ( nativeptr != nullptr ?
+            gcnew RegionEntry( nativeptr ) : nullptr );
+        }
+
+
+      private:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline RegionEntry( gemfire::RegionEntry* nativeptr )
+          : SBWrap( nativeptr ) { }
+      };
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionEventM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionEventM.cpp b/geode-client-native/src/clicache/RegionEventM.cpp
new file mode 100644
index 0000000..7c4d5f1
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionEventM.cpp
@@ -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.
+ *=========================================================================
+ */
+
+#include "gf_includes.hpp"
+#include "RegionEventM.hpp"
+#include "RegionM.hpp"
+#include "impl/SafeConvert.hpp"
+
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      RegionEvent::RegionEvent(GemStone::GemFire::Cache::Region^ region,
+        IGFSerializable^ aCallbackArgument, bool remoteOrigin)
+        : UMWrap( )
+      {
+        if ( region == nullptr ) {
+          throw gcnew IllegalArgumentException( "RegionEvent.ctor(): "
+            "null region passed" );
+        }
+
+        gemfire::UserDataPtr callbackptr(SafeMSerializableConvert(
+            aCallbackArgument));
+
+        SetPtr(new gemfire::RegionEvent(gemfire::RegionPtr(region->_NativePtr),
+          callbackptr, remoteOrigin), true);
+      }
+
+      GemStone::GemFire::Cache::Region^ RegionEvent::Region::get( )
+      {
+        gemfire::RegionPtr& regionptr( NativePtr->getRegion( ) );
+
+        return GemStone::GemFire::Cache::Region::Create( regionptr.ptr( ) );
+      }
+
+      IGFSerializable^ RegionEvent::CallbackArgument::get()
+      {
+        gemfire::UserDataPtr& valptr(NativePtr->getCallbackArgument());
+        return SafeUMSerializableConvert(valptr.ptr());
+      }
+
+      bool RegionEvent::RemoteOrigin::get( )
+      {
+        return NativePtr->remoteOrigin( );
+      }
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionEventM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionEventM.hpp b/geode-client-native/src/clicache/RegionEventM.hpp
new file mode 100644
index 0000000..d2a3673
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionEventM.hpp
@@ -0,0 +1,84 @@
+/*=========================================================================
+ * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+ * This product is protected by U.S. and international copyright
+ * and intellectual property laws. Pivotal products are covered by
+ * more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/RegionEvent.hpp"
+#include "impl/NativeWrapper.hpp"
+#include "IGFSerializable.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+
+      ref class Region;
+
+      /// <summary>
+      /// This class encapsulates events that occur for a region.
+      /// </summary>
+      [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class RegionEvent sealed
+        : public Internal::UMWrap<gemfire::RegionEvent>
+      {
+      public:
+
+        /// <summary>
+        /// Constructor to create a <c>RegionEvent</c> for a given region.
+        /// </summary>
+        /// <exception cref="IllegalArgumentException">
+        /// if region is null
+        /// </exception>
+        RegionEvent(Region^ region, IGFSerializable^ aCallbackArgument,
+          bool remoteOrigin);
+
+        /// <summary>
+        /// Return the region this event occurred in.
+        /// </summary>
+        property Region^ Region
+        {
+          GemStone::GemFire::Cache::Region^ get( );
+        }
+
+        /// <summary>
+        /// Returns the callbackArgument passed to the method that generated
+        /// this event. See the <see cref="Region" /> interface methods
+        /// that take a callbackArgument parameter.
+        /// </summary>
+        property IGFSerializable^ CallbackArgument
+        {
+          IGFSerializable^ get();
+        }
+
+        /// <summary>
+        /// Returns true if the event originated in a remote process.
+        /// </summary>
+        property bool RemoteOrigin
+        {
+          bool get( );
+        }
+
+
+      internal:
+
+        /// <summary>
+        /// Internal constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline RegionEvent( const gemfire::RegionEvent* nativeptr )
+          : UMWrap( const_cast<gemfire::RegionEvent*>( nativeptr ), false ) { }
+      };
+
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionFactoryM.cpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionFactoryM.cpp b/geode-client-native/src/clicache/RegionFactoryM.cpp
new file mode 100755
index 0000000..f46aa8a
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionFactoryM.cpp
@@ -0,0 +1,272 @@
+/*=========================================================================
+ * 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 "RegionFactoryM.hpp"
+#include "AttributesFactoryM.hpp"
+#include "RegionM.hpp"
+#include "impl/ManagedCacheLoader.hpp"
+#include "impl/ManagedCacheWriter.hpp"
+#include "impl/ManagedCacheListener.hpp"
+#include "impl/ManagedPartitionResolver.hpp"
+#include "impl/ManagedFixedPartitionResolver.hpp"
+#include "RegionAttributesM.hpp"
+#include "PropertiesM.hpp"
+#include "ICacheLoader.hpp"
+#include "ICacheWriter.hpp"
+#include "ICacheListener.hpp"
+#include "IPartitionResolver.hpp"
+#include "IFixedPartitionResolver.hpp"
+#include "impl/SafeConvert.hpp"
+
+#include "com/vmware/impl/ManagedCacheLoaderN.hpp"
+#include "com/vmware/impl/ManagedCacheWriterN.hpp"
+#include "com/vmware/impl/ManagedCacheListenerN.hpp"
+#include "com/vmware/impl/ManagedPartitionResolverN.hpp"
+#include "com/vmware/impl/ManagedFixedPartitionResolverN.hpp"
+
+#include "com/vmware/impl/CacheLoaderMN.hpp"
+#include "com/vmware/impl/CacheWriterMN.hpp"
+#include "com/vmware/impl/CacheListenerMN.hpp"
+#include "com/vmware/impl/PartitionResolverMN.hpp"
+#include "com/vmware/impl/FixedPartitionResolverMN.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      Region^ RegionFactory::Create(String^ regionName)
+      {
+        _GF_MG_EXCEPTION_TRY
+
+          ManagedString mg_name( regionName );
+          
+        gemfire::RegionPtr& nativeptr( NativePtr->create(
+            mg_name.CharPtr ) );
+          return Region::Create( nativeptr.ptr( ) );
+
+        _GF_MG_EXCEPTION_CATCH_ALL
+      }
+
+        RegionFactory^ RegionFactory::SetCacheLoader( ICacheLoader^ cacheLoader )
+      {
+        gemfire::CacheLoaderPtr loaderptr;
+        if ( cacheLoader != nullptr ) {
+          loaderptr = new gemfire::ManagedCacheLoader( cacheLoader );
+        }
+        NativePtr->setCacheLoader( loaderptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCacheWriter( ICacheWriter^ cacheWriter )
+      {
+        gemfire::CacheWriterPtr writerptr;
+        if ( cacheWriter != nullptr ) {
+          writerptr = new gemfire::ManagedCacheWriter( cacheWriter );
+        }
+        NativePtr->setCacheWriter( writerptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCacheListener( ICacheListener^ cacheListener )
+      {
+        gemfire::CacheListenerPtr listenerptr;
+        if ( cacheListener != nullptr ) {
+          listenerptr = new gemfire::ManagedCacheListener( cacheListener );
+        }
+        NativePtr->setCacheListener( listenerptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetPartitionResolver( IPartitionResolver^ partitionresolver )
+      {
+        gemfire::PartitionResolverPtr resolverptr;
+        if ( partitionresolver != nullptr ) {
+          IFixedPartitionResolver^ resolver = dynamic_cast<IFixedPartitionResolver^>(partitionresolver);
+          if (resolver != nullptr) {
+            resolverptr = new gemfire::ManagedFixedPartitionResolver( resolver );            
+          }
+          else {
+            resolverptr = new gemfire::ManagedPartitionResolver( partitionresolver );
+          }          
+        }
+        NativePtr->setPartitionResolver( resolverptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCacheLoader( String^ libPath, String^ factoryFunctionName )
+      {        
+        ManagedString mg_libpath( libPath );
+        ManagedString mg_factoryFunctionName( factoryFunctionName );
+
+        NativePtr->setCacheLoader( mg_libpath.CharPtr,
+          mg_factoryFunctionName.CharPtr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCacheWriter( String^ libPath, String^ factoryFunctionName )
+      {        
+        ManagedString mg_libpath( libPath );
+        ManagedString mg_factoryFunctionName( factoryFunctionName );
+
+        NativePtr->setCacheWriter( mg_libpath.CharPtr,
+          mg_factoryFunctionName.CharPtr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCacheListener( String^ libPath, String^ factoryFunctionName )
+      {        
+        ManagedString mg_libpath( libPath );
+        ManagedString mg_factoryFunctionName( factoryFunctionName );
+
+        NativePtr->setCacheListener( mg_libpath.CharPtr,
+          mg_factoryFunctionName.CharPtr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetPartitionResolver( String^ libPath, String^ factoryFunctionName )
+      {        
+        ManagedString mg_libpath( libPath );
+        ManagedString mg_factoryFunctionName( factoryFunctionName );
+
+        NativePtr->setPartitionResolver( mg_libpath.CharPtr,
+          mg_factoryFunctionName.CharPtr );
+        return this;
+      }
+
+      // EXPIRATION ATTRIBUTES
+
+      RegionFactory^ RegionFactory::SetEntryIdleTimeout( ExpirationAction action, uint32_t idleTimeout )
+      {
+        NativePtr->setEntryIdleTimeout(
+          static_cast<gemfire::ExpirationAction::Action>( action ), idleTimeout );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetEntryTimeToLive( ExpirationAction action, uint32_t timeToLive )
+      {
+        NativePtr->setEntryTimeToLive(
+          static_cast<gemfire::ExpirationAction::Action>( action ), timeToLive );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetRegionIdleTimeout( ExpirationAction action, uint32_t idleTimeout )
+      {
+        NativePtr->setRegionIdleTimeout(
+          static_cast<gemfire::ExpirationAction::Action>( action ), idleTimeout );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetRegionTimeToLive( ExpirationAction action, uint32_t timeToLive )
+      {
+        NativePtr->setRegionTimeToLive(
+          static_cast<gemfire::ExpirationAction::Action>( action ), timeToLive );
+        return this;
+      }
+
+      // PERSISTENCE
+
+      RegionFactory^ RegionFactory::SetPersistenceManager( String^ libPath,
+        String^ factoryFunctionName )
+      {        
+        SetPersistenceManager( libPath, factoryFunctionName, nullptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetPersistenceManager( String^ libPath,
+        String^ factoryFunctionName, Properties^ config )
+      {        
+        ManagedString mg_libpath( libPath );
+        ManagedString mg_factoryFunctionName( factoryFunctionName );
+        gemfire::PropertiesPtr configptr(
+          GetNativePtr<gemfire::Properties>( config ) );
+
+        NativePtr->setPersistenceManager( mg_libpath.CharPtr,
+          mg_factoryFunctionName.CharPtr, configptr );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetPoolName( String^ poolName )
+      {
+        ManagedString mg_poolName( poolName );
+
+        NativePtr->setPoolName( mg_poolName.CharPtr );
+        return this;
+      }
+
+      // MAP ATTRIBUTES
+
+      RegionFactory^ RegionFactory::SetInitialCapacity( int32_t initialCapacity )
+      {
+        _GF_MG_EXCEPTION_TRY
+
+          NativePtr->setInitialCapacity( initialCapacity );
+          return this;
+
+        _GF_MG_EXCEPTION_CATCH_ALL
+      }
+
+      RegionFactory^ RegionFactory::SetLoadFactor( Single loadFactor )
+      {
+        _GF_MG_EXCEPTION_TRY
+
+          NativePtr->setLoadFactor( loadFactor );
+          return this;
+
+        _GF_MG_EXCEPTION_CATCH_ALL
+      }
+
+      RegionFactory^ RegionFactory::SetConcurrencyLevel( int32_t concurrencyLevel )
+      {
+        _GF_MG_EXCEPTION_TRY
+
+          NativePtr->setConcurrencyLevel( concurrencyLevel );
+          return this;
+
+        _GF_MG_EXCEPTION_CATCH_ALL
+      }
+
+      RegionFactory^ RegionFactory::SetLruEntriesLimit( uint32_t entriesLimit )
+      {
+        NativePtr->setLruEntriesLimit( entriesLimit );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetDiskPolicy( DiskPolicyType diskPolicy )
+      {
+        NativePtr->setDiskPolicy(
+          static_cast<gemfire::DiskPolicyType::PolicyType>( diskPolicy ) );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCachingEnabled( bool cachingEnabled )
+      {
+        NativePtr->setCachingEnabled( cachingEnabled );
+        return this;
+      }
+
+      RegionFactory^ RegionFactory::SetCloningEnabled( bool cloningEnabled )
+      {
+        NativePtr->setCloningEnabled( cloningEnabled );
+        return this;
+      }
+      
+      RegionFactory^ RegionFactory::SetConcurrencyChecksEnabled( bool concurrencyChecksEnabled )
+      {
+        NativePtr->setConcurrencyChecksEnabled( concurrencyChecksEnabled );
+        return this;
+      }
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/ac967000/geode-client-native/src/clicache/RegionFactoryM.hpp
----------------------------------------------------------------------
diff --git a/geode-client-native/src/clicache/RegionFactoryM.hpp b/geode-client-native/src/clicache/RegionFactoryM.hpp
new file mode 100755
index 0000000..5413ba4
--- /dev/null
+++ b/geode-client-native/src/clicache/RegionFactoryM.hpp
@@ -0,0 +1,410 @@
+/*=========================================================================
+ * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
+ * This product is protected by U.S. and international copyright
+ * and intellectual property laws. Pivotal products are covered by
+ * more patents listed at http://www.pivotal.io/patents.
+ *=========================================================================
+ */
+
+#pragma once
+
+#include "gf_defs.hpp"
+#include "cppcache/AttributesFactory.hpp"
+#include "impl/NativeWrapper.hpp"
+#include "ExpirationActionM.hpp"
+#include "DiskPolicyTypeM.hpp"
+#include "ScopeTypeM.hpp"
+#include "cppcache/RegionFactory.hpp"
+#include "RegionM.hpp"
+#include "RegionShortcutM.hpp"
+
+#include "ICacheLoader.hpp"
+#include "ICacheWriter.hpp"
+#include "ICacheListener.hpp"
+#include "IPartitionResolver.hpp"
+
+using namespace System;
+
+namespace GemStone
+{
+  namespace GemFire
+  {
+    namespace Cache
+    {
+      ref class Properties;
+      //interface class ICacheLoader;
+      //interface class ICacheWriter;
+      //interface class ICacheListener;
+      //interface class IPartitionResolver;
+
+      /// <summary>
+      /// This interface provides for the configuration and creation of instances of Region.
+      /// </summary>
+      [Obsolete("Use classes and APIs from the GemStone.GemFire.Cache.Generic namespace")]
+      public ref class RegionFactory sealed
+        : public Internal::SBWrap<gemfire::RegionFactory>
+      {
+      public:
+        /// <summary>
+        /// Creates a region with the given name. 
+        /// The region is just created locally. It is not created on the server
+        /// to which this client is connected with.
+        /// </summary>
+        /// <remarks>
+        /// If Pool attached with Region is in multiusersecure mode then don't use return instance of region as no credential are attached with this instance.
+        /// Get instance of region from <see cref="Cache.CreateAuthenticatedView" to do the operation on Cache. 
+        /// </remarks>
+        /// <param name="name">the name of the region to create</param>
+        /// <returns>new region</returns>
+        /// <exception cref="RegionExistsException">
+        /// if a region with the same name is already in this cache
+        /// </exception>
+        /// <exception cref="CacheClosedException">
+        /// if the cache is closed
+        /// </exception>
+        /// <exception cref="OutOfMemoryException">
+        /// if the memory allocation failed
+        /// </exception>
+        /// <exception cref="RegionCreationFailedException">
+        /// if the call fails due to incomplete mirror initialization
+        /// </exception>
+        /// <exception cref="InitFailedException">
+        /// if the optional PersistenceManager fails to initialize
+        /// </exception>
+        /// <exception cref="UnknownException">otherwise</exception>
+        Region^ Create(String^ regionName);
+
+		    /// <summary>
+        /// Sets the cache loader for the <c>RegionAttributes</c> being created.
+        /// </summary>
+        /// <param name="cacheLoader">
+        /// a user-defined cache loader, or null for no cache loader
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheLoader( ICacheLoader^ cacheLoader );
+
+        /// <summary>
+        /// Sets the cache writer for the <c>RegionAttributes</c> being created.
+        /// </summary>
+        /// <param name="cacheWriter">
+        /// user-defined cache writer, or null for no cache writer
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheWriter( ICacheWriter^ cacheWriter );
+
+        /// <summary>
+        /// Sets the CacheListener for the <c>RegionAttributes</c> being created.
+        /// </summary>
+        /// <param name="cacheListener">
+        /// user-defined cache listener, or null for no cache listener
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheListener( ICacheListener^ cacheListener );
+
+        /// <summary>
+        /// Sets the PartitionResolver for the <c>RegionAttributes</c> being created.
+        /// </summary>
+        /// <param name="partitionresolver">
+        /// user-defined partition resolver, or null for no partition resolver
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetPartitionResolver( IPartitionResolver^ partitionresolver );
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the loader of the region.
+        /// </summary>
+        /// <param name="libPath">
+        /// library pathname containing the factory function.
+        /// </param>
+        /// <param name="factoryFunctionName">
+        /// Name of factory function that creates a <c>CacheLoader</c>
+        /// for a native library, or the name of the method in the form
+        /// {Namespace}.{Class Name}.{Method Name} that creates an
+        /// <c>ICacheLoader</c> for a managed library.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheLoader( String^ libPath, String^ factoryFunctionName );
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the writer of the region.
+        /// </summary>
+        /// <param name="libPath">
+        /// library pathname containing the factory function.
+        /// </param>
+        /// <param name="factoryFunctionName">
+        /// Name of factory function that creates a <c>CacheWriter</c>
+        /// for a native library, or the name of the method in the form
+        /// {Namespace}.{Class Name}.{Method Name} that creates an
+        /// <c>ICacheWriter</c> for a managed library.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheWriter( String^ libPath, String^ factoryFunctionName );
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the listener of the region.
+        /// </summary>
+        /// <param name="libPath">
+        /// library pathname containing the factory function.
+        /// </param>
+        /// <param name="factoryFunctionName">
+        /// Name of factory function that creates a <c>CacheListener</c>
+        /// for a native library, or the name of the method in the form
+        /// {Namespace}.{Class Name}.{Method Name} that creates an
+        /// <c>ICacheListener</c> for a managed library.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCacheListener( String^ libPath, String^ factoryFunctionName );
+
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the partition resolver of the region.
+        /// </summary>
+        /// <param name="libPath">
+        /// library pathname containing the factory function.
+        /// </param>
+        /// <param name="factoryFunctionName">
+        /// Name of factory function that creates a <c>PartitionResolver</c>
+        /// for a native library, or the name of the method in the form
+        /// {Namespace}.{Class Name}.{Method Name} that creates an
+        /// <c>IPartitionResolver</c> for a managed library.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetPartitionResolver( String^ libPath, String^ factoryFunctionName );
+        
+        /// <summary>
+        /// Sets the idleTimeout expiration attributes for region entries for the next
+        /// <c>RegionAttributes</c> created.
+        /// </summary>
+        /// <param name="action">
+        /// The expiration action for which to set the timeout.
+        /// </param>
+        /// <param name="idleTimeout">
+        /// the idleTimeout in seconds for entries in this region.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetEntryIdleTimeout( ExpirationAction action, uint32_t idleTimeout );
+
+        /// <summary>
+        /// Sets the timeToLive expiration attributes for region entries for the next
+        /// <c>RegionAttributes</c> created.
+        /// </summary>
+        /// <param name="action">
+        /// The expiration action for which to set the timeout.
+        /// </param>
+        /// <param name="timeToLive">
+        /// the timeToLive in seconds for entries in this region.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetEntryTimeToLive( ExpirationAction action, uint32_t timeToLive );
+
+        /// <summary>
+        /// Sets the idleTimeout expiration attributes for the region itself for the
+        /// next <c>RegionAttributes</c> created.
+        /// </summary>
+        /// <param name="action">
+        /// The expiration action for which to set the timeout.
+        /// </param>
+        /// <param name="idleTimeout">
+        /// the idleTimeout in seconds for the region as a whole.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetRegionIdleTimeout( ExpirationAction action, uint32_t idleTimeout );
+
+        /// <summary>
+        /// Sets the timeToLive expiration attributes for the region itself for the
+        /// next <c>RegionAttributes</c> created.
+        /// </summary>
+        /// <param name="action">
+        /// The expiration action for which to set the timeout.
+        /// </param>
+        /// <param name="timeToLive">
+        /// the timeToLive in seconds for the region as a whole.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetRegionTimeToLive( ExpirationAction action, uint32_t timeToLive );
+
+
+        // PERSISTENCE
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the persistence of the region.
+        /// If the region is being created from a client on a server, or on a server directly, then
+        /// This must be used to set the PersistenceManager.
+        /// </summary>
+        /// <param name="libPath">The path of the PersistenceManager shared library.</param>
+        /// <param name="factoryFunctionName">
+        /// The name of the factory function to create an instance of PersistenceManager object.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetPersistenceManager( String^ libPath, String^ factoryFunctionName );
+
+        /// <summary>
+        /// Sets the library path for the library that will be invoked for the persistence of the region.
+        /// If the region is being created from a client on a server, or on a server directly, then
+        /// This must be used to set the PersistenceManager.
+        /// </summary>
+        /// <param name="libPath">The path of the PersistenceManager shared library.</param>
+        /// <param name="factoryFunctionName">
+        /// The name of the factory function to create an instance of PersistenceManager object.
+        /// </param>
+        /// <param name="config">
+        /// The configuration properties to use for the PersistenceManager.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetPersistenceManager( String^ libPath, String^ factoryFunctionName,
+          Properties^ config );
+
+        /// <summary>
+        /// Set the pool name for a Thin Client region.
+        /// </summary>
+        /// <remarks>
+        /// The pool with the name specified must be already created.
+        /// </remarks>
+        /// <param name="poolName">
+        /// The name of the pool to attach to this region.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetPoolName( String^ poolName );
+
+        // MAP ATTRIBUTES
+
+        /// <summary>
+        /// Sets the entry initial capacity for the <c>RegionAttributes</c>
+        /// being created. This value is used in initializing the map that
+        /// holds the entries.
+        /// </summary>
+        /// <param name="initialCapacity">the initial capacity of the entry map</param>
+        /// <exception cref="IllegalArgumentException">
+        /// if initialCapacity is nonpositive
+        /// </exception>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetInitialCapacity( int32_t initialCapacity );
+
+        /// <summary>
+        /// Sets the entry load factor for the next <c>RegionAttributes</c>
+        /// created. This value is
+        /// used in initializing the map that holds the entries.
+        /// </summary>
+        /// <param name="loadFactor">the load factor of the entry map</param>
+        /// <exception cref="IllegalArgumentException">
+        /// if loadFactor is nonpositive
+        /// </exception>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetLoadFactor( Single loadFactor );
+
+        /// <summary>
+        /// Sets the concurrency level of the next <c>RegionAttributes</c>
+        /// created. This value is used in initializing the map that holds the entries.
+        /// </summary>
+        /// <param name="concurrencyLevel">
+        /// the concurrency level of the entry map
+        /// </param>
+        /// <exception cref="IllegalArgumentException">
+        /// if concurrencyLevel is nonpositive
+        /// </exception>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetConcurrencyLevel( int32_t concurrencyLevel );
+
+        /// <summary>
+        /// Sets a limit on the number of entries that will be held in the cache.
+        /// If a new entry is added while at the limit, the cache will evict the
+        /// least recently used entry.
+        /// </summary>
+        /// <param name="entriesLimit">
+        /// The limit of the number of entries before eviction starts.
+        /// Defaults to 0, meaning no LRU actions will used.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetLruEntriesLimit( uint32_t entriesLimit );
+
+        /// <summary>
+        /// Sets the disk policy type for the next <c>RegionAttributes</c> created.
+        /// </summary>
+        /// <param name="diskPolicy">
+        /// the disk policy to use for the region
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetDiskPolicy( DiskPolicyType diskPolicy );
+
+        /// <summary>
+        /// Set caching enabled flag for this region.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// If set to false, then no data is stored in the local process,
+        /// but events and distributions will still occur, and the region
+        /// can still be used to put and remove, etc...
+        /// </para><para>
+        /// The default if not set is 'true', 'false' is illegal for regions
+        /// of <c>ScopeType.Local</c> scope. 
+        /// </para>
+        /// </remarks>
+        /// <param name="cachingEnabled">
+        /// if true, cache data for this region in this process.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCachingEnabled( bool cachingEnabled );
+        /// <summary>
+        /// Set cloning enabled flag for this region.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// If set to false, then there is no cloning will take place in case of delta.
+        /// Delta will be applied on the old value which will change old value in-place.
+        /// </para><para>
+        /// The default if not set is 'false'
+        /// of <c>ScopeType.Local</c> scope. 
+        /// </para>
+        /// </remarks>
+        /// <param name="cloningEnabled">
+        /// if true, clone old value before applying delta so that in-place change would not occour..
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetCloningEnabled( bool cloningEnabled );
+
+        /// <summary>
+        /// Sets concurrency checks enabled flag for this region.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// If set to false, then the version checks will not occur.
+        /// </para><para>
+        /// The default if not set is 'true'
+        /// </para>
+        /// </remarks>
+        /// <param name="concurrencyChecksEnabled">
+        /// if true, version checks for region entries will occur.
+        /// </param>
+        /// <returns>the instance of RegionFactory</returns>
+        RegionFactory^ SetConcurrencyChecksEnabled( bool concurrencyChecksEnabled );
+
+    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 RegionFactory^ Create( gemfire::RegionFactory* nativeptr )
+      {
+        return ( nativeptr != nullptr ?
+          gcnew RegionFactory( nativeptr ) : nullptr );
+      }
+
+	  private:
+
+        /// <summary>
+        /// Private constructor to wrap a native object pointer
+        /// </summary>
+        /// <param name="nativeptr">The native object pointer</param>
+        inline RegionFactory( gemfire::RegionFactory* nativeptr )
+          : SBWrap( nativeptr ) { }
+      };
+
+    }
+  }
+}
+


Mime
View raw message