http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/TransactionId.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/TransactionId.hpp b/src/clicache/src/TransactionId.hpp index bfe1fdf..bc9339f 100644 --- a/src/clicache/src/TransactionId.hpp +++ b/src/clicache/src/TransactionId.hpp @@ -35,11 +35,11 @@ namespace GemStone /// This class encapsulates Id of a transaction. /// </summary> public ref class TransactionId sealed - : public Internal::SBWrap<gemfire::TransactionId> + : public Internal::SBWrap<apache::geode::client::TransactionId> { internal: - inline static TransactionId^ Create( gemfire::TransactionId* nativeptr ) + inline static TransactionId^ Create( apache::geode::client::TransactionId* nativeptr ) { return ( nativeptr != nullptr ? gcnew TransactionId( nativeptr ) : nullptr ); @@ -51,7 +51,7 @@ namespace GemStone /// Private constructor to wrap a native object pointer /// </summary> /// <param name="nativeptr">The native object pointer</param> - inline TransactionId( gemfire::TransactionId* nativeptr ) + inline TransactionId( apache::geode::client::TransactionId* nativeptr ) : SBWrap( nativeptr ) { } }; }
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/UserFunctionExecutionException.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/UserFunctionExecutionException.cpp b/src/clicache/src/UserFunctionExecutionException.cpp index 49217e0..27df568 100644 --- a/src/clicache/src/UserFunctionExecutionException.cpp +++ b/src/clicache/src/UserFunctionExecutionException.cpp @@ -55,7 +55,7 @@ namespace GemStone { _GF_MG_EXCEPTION_TRY2 - gemfire::CacheableStringPtr value = NativePtr->getMessage( ); + apache::geode::client::CacheableStringPtr value = NativePtr->getMessage( ); return CacheableString::GetString( value.ptr( ) ); _GF_MG_EXCEPTION_CATCH_ALL2 @@ -65,7 +65,7 @@ namespace GemStone { _GF_MG_EXCEPTION_TRY2 - gemfire::CacheableStringPtr value = NativePtr->getName( ); + apache::geode::client::CacheableStringPtr value = NativePtr->getName( ); return CacheableString::GetString( value.ptr( ) ); _GF_MG_EXCEPTION_CATCH_ALL2 http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/UserFunctionExecutionException.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/UserFunctionExecutionException.hpp b/src/clicache/src/UserFunctionExecutionException.hpp index 1dfa091..2178eae 100644 --- a/src/clicache/src/UserFunctionExecutionException.hpp +++ b/src/clicache/src/UserFunctionExecutionException.hpp @@ -38,7 +38,7 @@ namespace GemStone /// UserFunctionExecutionException class is used to encapsulate gemfire sendException in case of Function execution. /// </summary> public ref class UserFunctionExecutionException sealed - : public Internal::SBWrap<gemfire::UserFunctionExecutionException>, public IGFSerializable + : public Internal::SBWrap<apache::geode::client::UserFunctionExecutionException>, public IGFSerializable { public: // IGFSerializable members @@ -124,7 +124,7 @@ namespace GemStone /// Private constructor to wrap a native object pointer. /// </summary> /// <param name="nativeptr">The native object pointer</param> - inline UserFunctionExecutionException( gemfire::UserFunctionExecutionException* nativeptr ) + inline UserFunctionExecutionException( apache::geode::client::UserFunctionExecutionException* nativeptr ) : SBWrap( nativeptr ) { } }; http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/Utils.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/Utils.cpp b/src/clicache/src/Utils.cpp index d5b1230..3f8cb33 100644 --- a/src/clicache/src/Utils.cpp +++ b/src/clicache/src/Utils.cpp @@ -70,7 +70,7 @@ namespace GemStone int32_t Utils::LastError::get( ) { - return gemfire::Utils::getLastError( ); + return apache::geode::client::Utils::getLastError( ); } } } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/AppDomainContext.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/AppDomainContext.cpp b/src/clicache/src/impl/AppDomainContext.cpp index f500e51..d3fd91e 100644 --- a/src/clicache/src/impl/AppDomainContext.cpp +++ b/src/clicache/src/impl/AppDomainContext.cpp @@ -21,7 +21,7 @@ namespace GemStone { namespace GemFire { namespace Cache { namespace Generic { -gemfire::AppDomainContext* createAppDomainContext() { +apache::geode::client::AppDomainContext* createAppDomainContext() { return new AppDomainContext(); } } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/AppDomainContext.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/AppDomainContext.hpp b/src/clicache/src/impl/AppDomainContext.hpp index a97ad5f..9135e5b 100644 --- a/src/clicache/src/impl/AppDomainContext.hpp +++ b/src/clicache/src/impl/AppDomainContext.hpp @@ -46,7 +46,7 @@ public: * Captures the current thread's AppDomain for later use in associating a native * thread with this instanaces AppDomain. */ -class AppDomainContext : public gemfire::AppDomainContext { +class AppDomainContext : public apache::geode::client::AppDomainContext { public: AppDomainContext() { functionDelegate = gcnew AppDomainContextWrapper::Delegate(gcnew AppDomainContextWrapper(), @@ -64,7 +64,7 @@ private: AppDomainContextWrapper::Function functionPointer; }; -gemfire::AppDomainContext* createAppDomainContext(); +apache::geode::client::AppDomainContext* createAppDomainContext(); } } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/AuthenticatedCache.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/AuthenticatedCache.cpp b/src/clicache/src/impl/AuthenticatedCache.cpp index b9e6a77..92edaba 100644 --- a/src/clicache/src/impl/AuthenticatedCache.cpp +++ b/src/clicache/src/impl/AuthenticatedCache.cpp @@ -56,7 +56,7 @@ namespace GemStone _GF_MG_EXCEPTION_TRY2 ManagedString mg_path( path ); - gemfire::RegionPtr& nativeptr( + apache::geode::client::RegionPtr& nativeptr( NativePtr->getRegion( mg_path.CharPtr ) ); return Generic::Region<TKey, TValue>::Create( nativeptr.ptr( ) ); @@ -77,14 +77,14 @@ namespace GemStone generic<class TKey, class TValue> array<IRegion<TKey, TValue>^>^ AuthenticatedCache::RootRegions( ) { - gemfire::VectorOfRegion vrr; + apache::geode::client::VectorOfRegion vrr; NativePtr->rootRegions( vrr ); array<IRegion<TKey, TValue>^>^ rootRegions = gcnew array<IRegion<TKey, TValue>^>( vrr.size( ) ); for( int32_t index = 0; index < vrr.size( ); index++ ) { - gemfire::RegionPtr& nativeptr( vrr[ index ] ); + apache::geode::client::RegionPtr& nativeptr( vrr[ index ] ); rootRegions[ index ] = Generic::Region<TKey, TValue>::Create( nativeptr.ptr( ) ); } return rootRegions; http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/AuthenticatedCache.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/AuthenticatedCache.hpp b/src/clicache/src/impl/AuthenticatedCache.hpp index a962e2c..c669106 100644 --- a/src/clicache/src/impl/AuthenticatedCache.hpp +++ b/src/clicache/src/impl/AuthenticatedCache.hpp @@ -61,7 +61,7 @@ namespace GemStone /// </para> /// </remarks> public ref class AuthenticatedCache - : public IRegionService, Internal::SBWrap<gemfire::RegionService> + : public IRegionService, Internal::SBWrap<apache::geode::client::RegionService> { public: @@ -147,7 +147,7 @@ namespace GemStone /// <returns> /// The managed wrapper object; null if the native pointer is null. /// </returns> - inline static AuthenticatedCache^ Create( gemfire::RegionService* nativeptr ) + inline static AuthenticatedCache^ Create( apache::geode::client::RegionService* nativeptr ) { return ( nativeptr != nullptr ? gcnew AuthenticatedCache( nativeptr ) : nullptr ); @@ -159,7 +159,7 @@ namespace GemStone /// Private constructor to wrap a native object pointer /// </summary> /// <param name="nativeptr">The native object pointer</param> - inline AuthenticatedCache( gemfire::RegionService* nativeptr ) + inline AuthenticatedCache( apache::geode::client::RegionService* nativeptr ) : SBWrap( nativeptr ) { } }; } // end namespace Generic http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/CacheListener.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/CacheListener.hpp b/src/clicache/src/impl/CacheListener.hpp index d2afdbe..e778672 100644 --- a/src/clicache/src/impl/CacheListener.hpp +++ b/src/clicache/src/impl/CacheListener.hpp @@ -49,61 +49,61 @@ namespace GemStone virtual void AfterUpdate(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ event) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(event)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(event)); m_listener->AfterUpdate(%gevent); } virtual void AfterCreate(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ event) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(event)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(event)); m_listener->AfterCreate(%gevent); } virtual void AfterInvalidate(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ event) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(event)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(event)); m_listener->AfterInvalidate(%gevent); } virtual void AfterDestroy(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ event) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(event)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(event)); m_listener->AfterDestroy(%gevent); } virtual void AfterRegionLive(GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ event) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(event)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(event)); m_listener->AfterRegionLive(%gevent); } virtual void AfterRegionClear(GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ event) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(event)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(event)); m_listener->AfterRegionClear(%gevent); } virtual void AfterRegionDestroy(GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ event) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(event)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(event)); m_listener->AfterRegionDestroy(%gevent); } virtual void AfterRegionInvalidate(GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ event) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(event)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(event)); m_listener->AfterRegionInvalidate(%gevent); } virtual void AfterRegionDisconnected(GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ event) override { - GemStone::GemFire::Cache::Generic::IRegion<TKey, TValue>^ gevent = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(GemStone::GemFire::Cache::Generic::GetNativePtr<gemfire::Region>(reinterpret_cast<GemStone::GemFire::Cache::Generic::Region<Object^, Object^>^>(event))); + GemStone::GemFire::Cache::Generic::IRegion<TKey, TValue>^ gevent = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(GemStone::GemFire::Cache::Generic::GetNativePtr<apache::geode::client::Region>(reinterpret_cast<GemStone::GemFire::Cache::Generic::Region<Object^, Object^>^>(event))); m_listener->AfterRegionDisconnected(gevent); } virtual void Close(GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ event) override { - GemStone::GemFire::Cache::Generic::IRegion<TKey, TValue>^ gevent = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(GemStone::GemFire::Cache::Generic::GetNativePtr<gemfire::Region>(reinterpret_cast<GemStone::GemFire::Cache::Generic::Region<Object^, Object^>^>(event))); + GemStone::GemFire::Cache::Generic::IRegion<TKey, TValue>^ gevent = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(GemStone::GemFire::Cache::Generic::GetNativePtr<apache::geode::client::Region>(reinterpret_cast<GemStone::GemFire::Cache::Generic::Region<Object^, Object^>^>(event))); m_listener->Close(gevent); } }; http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/CacheLoader.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/CacheLoader.hpp b/src/clicache/src/impl/CacheLoader.hpp index e1be614..1fe796a 100644 --- a/src/clicache/src/impl/CacheLoader.hpp +++ b/src/clicache/src/impl/CacheLoader.hpp @@ -40,10 +40,10 @@ namespace GemStone public interface class ICacheLoaderProxy { public: - gemfire::CacheablePtr load( const gemfire::RegionPtr& region, - const gemfire::CacheableKeyPtr& key, const gemfire::UserDataPtr& helper ); + apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region, + const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::UserDataPtr& helper ); - void close( const gemfire::RegionPtr& region ); + void close( const apache::geode::client::RegionPtr& region ); }; generic<class TKey, class TValue> @@ -60,8 +60,8 @@ namespace GemStone m_loader = loader; } - virtual gemfire::CacheablePtr load( const gemfire::RegionPtr& region, - const gemfire::CacheableKeyPtr& key, const gemfire::UserDataPtr& helper ) + virtual apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region, + const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::UserDataPtr& helper ) { IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.ptr()); @@ -73,7 +73,7 @@ namespace GemStone return Serializable::GetUnmanagedValueGeneric<TValue>(m_loader->Load(gregion, gkey, ghelper)); } - virtual void close( const gemfire::RegionPtr& region ) + virtual void close( const apache::geode::client::RegionPtr& region ) { IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.ptr()); m_loader->Close(gregion); http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/CacheWriter.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/CacheWriter.hpp b/src/clicache/src/impl/CacheWriter.hpp index 65a5e3f..7c7dc6f 100644 --- a/src/clicache/src/impl/CacheWriter.hpp +++ b/src/clicache/src/impl/CacheWriter.hpp @@ -49,37 +49,37 @@ namespace GemStone virtual bool BeforeUpdate( GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ ev ) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(ev)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(ev)); return m_writer->BeforeUpdate(%gevent); } virtual bool BeforeCreate(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ ev) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(ev)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(ev)); return m_writer->BeforeCreate(%gevent); } virtual bool BeforeDestroy(GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^>^ ev) override { - EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::EntryEvent>(ev)); + EntryEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::EntryEvent>(ev)); return m_writer->BeforeDestroy(%gevent); } virtual bool BeforeRegionClear( GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ ev ) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(ev)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(ev)); return m_writer->BeforeRegionClear(%gevent); } virtual bool BeforeRegionDestroy(GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^>^ ev) override { - RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<gemfire::RegionEvent>(ev)); + RegionEvent<TKey, TValue> gevent(Generic::GetNativePtr<apache::geode::client::RegionEvent>(ev)); return m_writer->BeforeRegionDestroy(%gevent); } virtual void Close(GemStone::GemFire::Cache::Generic::Region<Object^, Object^>^ region) override { - IRegion<TKey, TValue>^ gregion = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(Generic::GetNativePtr<gemfire::Region>(region)); + IRegion<TKey, TValue>^ gregion = GemStone::GemFire::Cache::Generic::Region<TKey, TValue>::Create(Generic::GetNativePtr<apache::geode::client::Region>(region)); m_writer->Close(gregion); } }; http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/CqListenerProxy.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/CqListenerProxy.hpp b/src/clicache/src/impl/CqListenerProxy.hpp index da3b81f..5ff3793 100644 --- a/src/clicache/src/impl/CqListenerProxy.hpp +++ b/src/clicache/src/impl/CqListenerProxy.hpp @@ -47,14 +47,14 @@ namespace GemStone virtual void OnEvent( GemStone::GemFire::Cache::Generic::CqEvent<Object^, Object^>^ ev) { //TODO:split---Done - CqEvent<TKey, TResult> gevent(GetNativePtr<gemfire::CqEvent>(ev)); + CqEvent<TKey, TResult> gevent(GetNativePtr<apache::geode::client::CqEvent>(ev)); m_listener->OnEvent(%gevent); } virtual void OnError(GemStone::GemFire::Cache::Generic::CqEvent<Object^, Object^>^ ev) { //TODO::split--Done - CqEvent<TKey, TResult> gevent(GetNativePtr<gemfire::CqEvent>(ev)); + CqEvent<TKey, TResult> gevent(GetNativePtr<apache::geode::client::CqEvent>(ev)); m_listener->OnError(%gevent); } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/CqStatusListenerProxy.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/CqStatusListenerProxy.hpp b/src/clicache/src/impl/CqStatusListenerProxy.hpp index 2b7973b..05f33e4 100644 --- a/src/clicache/src/impl/CqStatusListenerProxy.hpp +++ b/src/clicache/src/impl/CqStatusListenerProxy.hpp @@ -45,14 +45,14 @@ namespace GemStone virtual void OnEvent(GemStone::GemFire::Cache::Generic::CqEvent<Object^, Object^>^ ev) { //TODO:split---Done - CqEvent<TKey, TResult> gevent(GetNativePtr<gemfire::CqEvent>(ev)); + CqEvent<TKey, TResult> gevent(GetNativePtr<apache::geode::client::CqEvent>(ev)); m_listener->OnEvent(%gevent); } virtual void OnError( GemStone::GemFire::Cache::Generic::CqEvent<Object^, Object^>^ ev) { //TODO::split--Done - CqEvent<TKey, TResult> gevent(GetNativePtr<gemfire::CqEvent>(ev)); + CqEvent<TKey, TResult> gevent(GetNativePtr<apache::geode::client::CqEvent>(ev)); m_listener->OnError(%gevent); } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/DelegateWrapper.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/DelegateWrapper.hpp b/src/clicache/src/impl/DelegateWrapper.hpp index abc989d..136afd5 100644 --- a/src/clicache/src/impl/DelegateWrapper.hpp +++ b/src/clicache/src/impl/DelegateWrapper.hpp @@ -36,7 +36,7 @@ namespace GemStone /// Template class to wrap a managed <see cref="TypeFactoryMethod" /> /// delegate that returns an <see cref="IGFSerializable" /> object. It contains /// a method that converts the managed object gotten by invoking the - /// delegate to the native <c>gemfire::Serializable</c> object + /// delegate to the native <c>apache::geode::client::Serializable</c> object /// (using the provided wrapper class constructor). /// </summary> /// <remarks> @@ -45,14 +45,14 @@ namespace GemStone /// In the managed world a user would register a managed type by providing /// a factory delegate returning an object of that type. However, the /// native implementation requires a factory function that returns an - /// object implementing <c>gemfire::Serializable</c>. Normally this would not + /// object implementing <c>apache::geode::client::Serializable</c>. Normally this would not /// be possible since we require to dynamically generate a new function /// for a given delegate. /// /// Fortunately in the managed world the delegates contain an implicit /// 'this' pointer. Thus we can have a universal delegate that contains /// the given managed delegate (in the 'this' pointer) and returns the - /// native <c>gemfire::Serializable</c> object. Additionally marshalling + /// native <c>apache::geode::client::Serializable</c> object. Additionally marshalling /// services provide <c>Marshal.GetFunctionPointerForDelegate</c> which gives /// a function pointer for a delegate which completes the conversion. /// </remarks> @@ -67,14 +67,14 @@ namespace GemStone : m_delegate( typeDelegate ) { } /// <summary> - /// Returns the native <c>gemfire::Serializable</c> object by invoking the + /// Returns the native <c>apache::geode::client::Serializable</c> object by invoking the /// managed delegate provided in the constructor. /// </summary> /// <returns> - /// Native <c>gemfire::Serializable</c> object after invoking the managed + /// Native <c>apache::geode::client::Serializable</c> object after invoking the managed /// delegate and wrapping inside a <c>ManagedCacheableKey</c> object. /// </returns> - gemfire::Serializable* NativeDelegateGeneric( ) + apache::geode::client::Serializable* NativeDelegateGeneric( ) { IGFSerializable^ tempObj = m_delegate( ); IGFDelta^ tempDelta = @@ -82,14 +82,14 @@ namespace GemStone if( tempDelta != nullptr ) { if(!SafeConvertClassGeneric::isAppDomainEnabled) - return new gemfire::ManagedCacheableDeltaGeneric( tempDelta ); + return new apache::geode::client::ManagedCacheableDeltaGeneric( tempDelta ); else - return new gemfire::ManagedCacheableDeltaBytesGeneric( tempDelta, false ); + return new apache::geode::client::ManagedCacheableDeltaBytesGeneric( tempDelta, false ); } else if(!SafeConvertClassGeneric::isAppDomainEnabled) - return new gemfire::ManagedCacheableKeyGeneric( tempObj); + return new apache::geode::client::ManagedCacheableKeyGeneric( tempObj); else - return new gemfire::ManagedCacheableKeyBytesGeneric( tempObj, false); + return new apache::geode::client::ManagedCacheableKeyBytesGeneric( tempObj, false); } http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/FixedPartitionResolver.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/FixedPartitionResolver.hpp b/src/clicache/src/impl/FixedPartitionResolver.hpp index 33a1cad..a5e19e3 100644 --- a/src/clicache/src/impl/FixedPartitionResolver.hpp +++ b/src/clicache/src/impl/FixedPartitionResolver.hpp @@ -34,9 +34,9 @@ namespace GemStone public interface class IFixedPartitionResolverProxy { public: - gemfire::CacheableKeyPtr getRoutingObject(const gemfire::EntryEvent& ev); + apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev); const char * getName(); - const char* getPartitionName(const gemfire::EntryEvent& opDetails); + const char* getPartitionName(const apache::geode::client::EntryEvent& opDetails); }; generic<class TKey, class TValue> @@ -56,7 +56,7 @@ namespace GemStone m_strList = gcnew Dictionary<String^, ManagedString^>(); } - virtual gemfire::CacheableKeyPtr getRoutingObject(const gemfire::EntryEvent& ev) + virtual apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev) { EntryEvent<TKey, TValue> gevent(&ev); Object^ groutingobject = m_resolver->GetRoutingObject(%gevent); @@ -69,11 +69,11 @@ namespace GemStone return mg_name.CharPtr; } - virtual const char* getPartitionName(const gemfire::EntryEvent& opDetails) + virtual const char* getPartitionName(const apache::geode::client::EntryEvent& opDetails) { if (m_fixedResolver == nullptr) { - throw gemfire::IllegalStateException("GetPartitionName() called on non fixed partition resolver."); + throw apache::geode::client::IllegalStateException("GetPartitionName() called on non fixed partition resolver."); } EntryEvent<TKey, TValue> gevent(&opDetails); http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedAuthInitialize.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/ManagedAuthInitialize.cpp b/src/clicache/src/impl/ManagedAuthInitialize.cpp index ac3cea3..731eec7 100644 --- a/src/clicache/src/impl/ManagedAuthInitialize.cpp +++ b/src/clicache/src/impl/ManagedAuthInitialize.cpp @@ -27,184 +27,190 @@ using namespace System; using namespace System::Text; using namespace System::Reflection; -namespace gemfire +namespace apache { - - AuthInitialize* ManagedAuthInitializeGeneric::create( const char* assemblyPath, - const char* factoryFunctionName ) + namespace geode { - try + namespace client { - String^ mg_assemblyPath = - GemStone::GemFire::Cache::Generic::ManagedString::Get( assemblyPath ); - String^ mg_factoryFunctionName = - GemStone::GemFire::Cache::Generic::ManagedString::Get( factoryFunctionName ); - String^ mg_typeName = nullptr; - int32_t dotIndx = -1; - - if (mg_factoryFunctionName == nullptr || - ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 ) - { - std::string ex_str = "ManagedAuthInitializeGeneric: Factory function name '"; - ex_str += factoryFunctionName; - ex_str += "' does not contain type name"; - throw AuthenticationRequiredException( ex_str.c_str( ) ); - } - - mg_typeName = mg_factoryFunctionName->Substring( 0, dotIndx ); - mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx + 1 ); - - /* - String^ mg_genericKey = GemStone::GemFire::ManagedString::Get("string"); - String^ mg_genericVal = GemStone::GemFire::ManagedString::Get("object"); - - StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName); - - typeBuilder->Append("`2"); - */ - Assembly^ assmb = nullptr; - try + AuthInitialize* ManagedAuthInitializeGeneric::create(const char* assemblyPath, + const char* factoryFunctionName) { - assmb = Assembly::Load( mg_assemblyPath ); - } - catch (System::Exception^) - { - assmb = nullptr; - } - if (assmb == nullptr) - { - std::string ex_str = "ManagedAuthInitializeGeneric: Could not load assembly: "; - ex_str += assemblyPath; - throw AuthenticationRequiredException( ex_str.c_str( ) ); - } - - Object^ typeInst = assmb->CreateInstance( mg_typeName, true ); - - //Type^ typeInst = assmb->GetType(mg_typeName, false, true); + try + { + String^ mg_assemblyPath = + GemStone::GemFire::Cache::Generic::ManagedString::Get(assemblyPath); + String^ mg_factoryFunctionName = + GemStone::GemFire::Cache::Generic::ManagedString::Get(factoryFunctionName); + String^ mg_typeName = nullptr; + int32_t dotIndx = -1; + + if (mg_factoryFunctionName == nullptr || + (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0) + { + std::string ex_str = "ManagedAuthInitializeGeneric: Factory function name '"; + ex_str += factoryFunctionName; + ex_str += "' does not contain type name"; + throw AuthenticationRequiredException(ex_str.c_str()); + } - if (typeInst != nullptr) - { - /* - array<Type^>^ types = gcnew array<Type^>(2); - types[0] = Type::GetType(mg_genericKey, false, true); - types[1] = Type::GetType(mg_genericVal, false, true); + mg_typeName = mg_factoryFunctionName->Substring(0, dotIndx); + mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1); - if (types[0] == nullptr || types[1] == nullptr) - { - std::string ex_str = "ManagedAuthInitializeGeneric: Could not get both generic type argument instances"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); - } - */ + /* + String^ mg_genericKey = GemStone::GemFire::ManagedString::Get("string"); + String^ mg_genericVal = GemStone::GemFire::ManagedString::Get("object"); - //typeInst = typeInst->GetType()->MakeGenericType(types); - GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName); + StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName); - /* - MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName, - BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase ); + typeBuilder->Append("`2"); */ - MethodInfo^ mInfo = typeInst->GetType( )->GetMethod( mg_factoryFunctionName, - BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase ); - - if (mInfo != nullptr) - { - Object^ userptr = nullptr; + Assembly^ assmb = nullptr; try { - userptr = mInfo->Invoke(typeInst, nullptr); + assmb = Assembly::Load(mg_assemblyPath); } catch (System::Exception^) { - userptr = nullptr; + assmb = nullptr; } - if (userptr == nullptr) + if (assmb == nullptr) { - std::string ex_str = "ManagedAuthInitializeGeneric: Could not create " - "object on invoking factory function ["; - ex_str += factoryFunctionName; + std::string ex_str = "ManagedAuthInitializeGeneric: Could not load assembly: "; + ex_str += assemblyPath; + throw AuthenticationRequiredException(ex_str.c_str()); + } + + Object^ typeInst = assmb->CreateInstance(mg_typeName, true); + + //Type^ typeInst = assmb->GetType(mg_typeName, false, true); + + if (typeInst != nullptr) + { + /* + array<Type^>^ types = gcnew array<Type^>(2); + types[0] = Type::GetType(mg_genericKey, false, true); + types[1] = Type::GetType(mg_genericVal, false, true); + + if (types[0] == nullptr || types[1] == nullptr) + { + std::string ex_str = "ManagedAuthInitializeGeneric: Could not get both generic type argument instances"; + throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) ); + } + */ + + //typeInst = typeInst->GetType()->MakeGenericType(types); + GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName); + + /* + MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName, + BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase ); + */ + + MethodInfo^ mInfo = typeInst->GetType()->GetMethod(mg_factoryFunctionName, + BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase); + + if (mInfo != nullptr) + { + Object^ userptr = nullptr; + try + { + userptr = mInfo->Invoke(typeInst, nullptr); + } + catch (System::Exception^) + { + userptr = nullptr; + } + if (userptr == nullptr) + { + std::string ex_str = "ManagedAuthInitializeGeneric: Could not create " + "object on invoking factory function ["; + ex_str += factoryFunctionName; + ex_str += "] in assembly: "; + ex_str += assemblyPath; + throw AuthenticationRequiredException(ex_str.c_str()); + } + ManagedAuthInitializeGeneric * maig = new ManagedAuthInitializeGeneric(safe_cast<GemStone::GemFire::Cache::Generic::IAuthInitialize^>(userptr)); + return maig; + } + else + { + std::string ex_str = "ManagedAuthInitializeGeneric: Could not load " + "function with name ["; + ex_str += factoryFunctionName; + ex_str += "] in assembly: "; + ex_str += assemblyPath; + throw AuthenticationRequiredException(ex_str.c_str()); + } + } + else + { + GemStone::GemFire::Cache::Generic::ManagedString typeName(mg_typeName); + std::string ex_str = "ManagedAuthInitializeGeneric: Could not load type ["; + ex_str += typeName.CharPtr; ex_str += "] in assembly: "; ex_str += assemblyPath; - throw AuthenticationRequiredException( ex_str.c_str( ) ); + throw AuthenticationRequiredException(ex_str.c_str()); } - ManagedAuthInitializeGeneric * maig = new ManagedAuthInitializeGeneric(safe_cast<GemStone::GemFire::Cache::Generic::IAuthInitialize^>(userptr)); - return maig; } - else + catch (const apache::geode::client::AuthenticationRequiredException&) + { + throw; + } + catch (const apache::geode::client::Exception& ex) { - std::string ex_str = "ManagedAuthInitializeGeneric: Could not load " - "function with name ["; - ex_str += factoryFunctionName; - ex_str += "] in assembly: "; - ex_str += assemblyPath; - throw AuthenticationRequiredException( ex_str.c_str( ) ); + std::string ex_str = "ManagedAuthInitializeGeneric: Got an exception while " + "loading managed library: "; + ex_str += ex.getName(); + ex_str += ": "; + ex_str += ex.getMessage(); + throw AuthenticationRequiredException(ex_str.c_str()); + } + catch (System::Exception^ ex) + { + GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString()); + std::string ex_str = "ManagedAuthInitializeGeneric: Got an exception while " + "loading managed library: "; + ex_str += mg_exStr.CharPtr; + throw AuthenticationRequiredException(ex_str.c_str()); + } + return NULL; + } + + PropertiesPtr ManagedAuthInitializeGeneric::getCredentials(PropertiesPtr& + securityprops, const char* server) + { + try { + GemStone::GemFire::Cache::Generic::Properties<String^, String^>^ mprops = + GemStone::GemFire::Cache::Generic::Properties<String^, String^>::Create<String^, String^>(securityprops.ptr()); + String^ mg_server = GemStone::GemFire::Cache::Generic::ManagedString::Get(server); + + return PropertiesPtr(m_managedptr->GetCredentials(mprops, mg_server)->NativePtr()); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } + return NULLPTR; } - else + + void ManagedAuthInitializeGeneric::close() { - GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName ); - std::string ex_str = "ManagedAuthInitializeGeneric: Could not load type ["; - ex_str += typeName.CharPtr; - ex_str += "] in assembly: "; - ex_str += assemblyPath; - throw AuthenticationRequiredException( ex_str.c_str( ) ); + try { + m_managedptr->Close(); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - } - catch (const gemfire::AuthenticationRequiredException&) - { - throw; - } - catch (const gemfire::Exception& ex) - { - std::string ex_str = "ManagedAuthInitializeGeneric: Got an exception while " - "loading managed library: "; - ex_str += ex.getName( ); - ex_str += ": "; - ex_str += ex.getMessage( ); - throw AuthenticationRequiredException( ex_str.c_str( ) ); - } - catch (System::Exception^ ex) - { - GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) ); - std::string ex_str = "ManagedAuthInitializeGeneric: Got an exception while " - "loading managed library: "; - ex_str += mg_exStr.CharPtr; - throw AuthenticationRequiredException( ex_str.c_str( ) ); - } - return NULL; - } - - PropertiesPtr ManagedAuthInitializeGeneric::getCredentials( PropertiesPtr& - securityprops, const char* server ) - { - try { - GemStone::GemFire::Cache::Generic::Properties<String^, String^>^ mprops = - GemStone::GemFire::Cache::Generic::Properties<String^, String^>::Create<String^, String^>(securityprops.ptr()); - String^ mg_server = GemStone::GemFire::Cache::Generic::ManagedString::Get( server ); - - return PropertiesPtr(m_managedptr->GetCredentials(mprops, mg_server)->NativePtr()); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - return NULLPTR; - } - - void ManagedAuthInitializeGeneric::close( ) - { - try { - m_managedptr->Close( ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - -} + + } // namespace client + } // namespace geode +} // namespace apache http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedAuthInitialize.hpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/ManagedAuthInitialize.hpp b/src/clicache/src/impl/ManagedAuthInitialize.hpp index b7fcfad..93df540 100644 --- a/src/clicache/src/impl/ManagedAuthInitialize.hpp +++ b/src/clicache/src/impl/ManagedAuthInitialize.hpp @@ -22,98 +22,103 @@ #include <vcclr.h> #include "../IAuthInitialize.hpp" -//using namespace gemfire; +//using namespace apache::geode::client; -namespace gemfire +namespace apache { - - /// <summary> - /// Wraps the managed <see cref="GemStone.GemFire.Cache.Generic.IAuthInitialize" /> - /// object and implements the native <c>gemfire::AuthInitialize</c> interface. - /// </summary> - class ManagedAuthInitializeGeneric - : public gemfire::AuthInitialize + namespace geode { - public: + namespace client + { - /// <summary> - /// Constructor to initialize with the provided managed object. - /// </summary> - /// <param name="managedptr"> - /// The managed object. - /// </param> - inline ManagedAuthInitializeGeneric(GemStone::GemFire::Cache::Generic::IAuthInitialize^ managedptr) - : m_managedptr(managedptr) { } + /// <summary> + /// Wraps the managed <see cref="GemStone.GemFire.Cache.Generic.IAuthInitialize" /> + /// object and implements the native <c>apache::geode::client::AuthInitialize</c> interface. + /// </summary> + class ManagedAuthInitializeGeneric + : public apache::geode::client::AuthInitialize + { + public: - /// <summary> - /// Static function to create a <c>ManagedAuthInitialize</c> using given - /// managed assembly path and given factory function. - /// </summary> - /// <param name="assemblyPath"> - /// The path of the managed assembly that contains the <c>IAuthInitialize</c> - /// factory function. - /// </param> - /// <param name="factoryFunctionName"> - /// The name of the factory function of the managed class for creating - /// an object that implements <c>IAuthInitialize</c>. - /// This should be a static function of the format - /// {Namespace}.{Class Name}.{Method Name}. - /// </param> - /// <exception cref="IllegalArgumentException"> - /// If the managed library cannot be loaded or the factory function fails. - /// </exception> - static AuthInitialize* create( const char* assemblyPath, - const char* factoryFunctionName ); + /// <summary> + /// Constructor to initialize with the provided managed object. + /// </summary> + /// <param name="managedptr"> + /// The managed object. + /// </param> + inline ManagedAuthInitializeGeneric(GemStone::GemFire::Cache::Generic::IAuthInitialize^ managedptr) + : m_managedptr(managedptr) { } - /// <summary> - /// Called when the cache is going down - /// </summary> - /// <remarks> - /// Implementations should clean up any external - /// resources, such as database connections. Any runtime exceptions this method - /// throws will be logged. - /// <para> - /// It is possible for this method to be called multiple times on a single - /// callback instance, so implementations must be tolerant of this. - /// </para> - /// </remarks> - /// <seealso cref="GemStone.GemFire.Cache.Cache.Close" /> - virtual void close( ); + /// <summary> + /// Static function to create a <c>ManagedAuthInitialize</c> using given + /// managed assembly path and given factory function. + /// </summary> + /// <param name="assemblyPath"> + /// The path of the managed assembly that contains the <c>IAuthInitialize</c> + /// factory function. + /// </param> + /// <param name="factoryFunctionName"> + /// The name of the factory function of the managed class for creating + /// an object that implements <c>IAuthInitialize</c>. + /// This should be a static function of the format + /// {Namespace}.{Class Name}.{Method Name}. + /// </param> + /// <exception cref="IllegalArgumentException"> + /// If the managed library cannot be loaded or the factory function fails. + /// </exception> + static AuthInitialize* create(const char* assemblyPath, + const char* factoryFunctionName); - /// <summary> - /// Initialize with the given set of security properties and return the - /// credentials for the given client as properties. - /// </summary> - /// <param name="securityprops">Given set of properties with which - /// to initialize - /// </param> - /// <param name="server">It is the ID of the endpoint - /// </param> - virtual PropertiesPtr getCredentials(PropertiesPtr& securityprops, const char* server); + /// <summary> + /// Called when the cache is going down + /// </summary> + /// <remarks> + /// Implementations should clean up any external + /// resources, such as database connections. Any runtime exceptions this method + /// throws will be logged. + /// <para> + /// It is possible for this method to be called multiple times on a single + /// callback instance, so implementations must be tolerant of this. + /// </para> + /// </remarks> + /// <seealso cref="GemStone.GemFire.Cache.Cache.Close" /> + virtual void close(); - virtual ~ManagedAuthInitializeGeneric( ) { } + /// <summary> + /// Initialize with the given set of security properties and return the + /// credentials for the given client as properties. + /// </summary> + /// <param name="securityprops">Given set of properties with which + /// to initialize + /// </param> + /// <param name="server">It is the ID of the endpoint + /// </param> + virtual PropertiesPtr getCredentials(PropertiesPtr& securityprops, const char* server); - /// <summary> - /// Returns the wrapped managed object reference. - /// </summary> - inline GemStone::GemFire::Cache::Generic::IAuthInitialize^ ptr( ) const - { - return m_managedptr; - } + virtual ~ManagedAuthInitializeGeneric() { } - private: + /// <summary> + /// Returns the wrapped managed object reference. + /// </summary> + inline GemStone::GemFire::Cache::Generic::IAuthInitialize^ ptr() const + { + return m_managedptr; + } - /// <summary> - /// Using gcroot to hold the managed delegate pointer (since it cannot be stored directly). - /// Note: not using auto_gcroot since it will result in 'Dispose' of the ICacheLoader - /// to be called which is not what is desired when this object is destroyed. Normally this - /// managed object may be created by the user and will be handled automatically by the GC. - /// </summary> - gcroot<GemStone::GemFire::Cache::Generic::IAuthInitialize^> m_managedptr; + private: - // Disable the copy and assignment constructors - ManagedAuthInitializeGeneric( const ManagedAuthInitializeGeneric& ); - ManagedAuthInitializeGeneric& operator = ( const ManagedAuthInitializeGeneric& ); - }; + /// <summary> + /// Using gcroot to hold the managed delegate pointer (since it cannot be stored directly). + /// Note: not using auto_gcroot since it will result in 'Dispose' of the ICacheLoader + /// to be called which is not what is desired when this object is destroyed. Normally this + /// managed object may be created by the user and will be handled automatically by the GC. + /// </summary> + gcroot<GemStone::GemFire::Cache::Generic::IAuthInitialize^> m_managedptr; -} + // Disable the copy and assignment constructors + ManagedAuthInitializeGeneric(const ManagedAuthInitializeGeneric&); + ManagedAuthInitializeGeneric& operator = (const ManagedAuthInitializeGeneric&); + }; + } // namespace client + } // namespace geode +} // namespace apache http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedCacheListener.cpp ---------------------------------------------------------------------- diff --git a/src/clicache/src/impl/ManagedCacheListener.cpp b/src/clicache/src/impl/ManagedCacheListener.cpp index 35a1498..fc678fb 100644 --- a/src/clicache/src/impl/ManagedCacheListener.cpp +++ b/src/clicache/src/impl/ManagedCacheListener.cpp @@ -31,326 +31,332 @@ using namespace System; using namespace System::Text; using namespace System::Reflection; -namespace gemfire +namespace apache { - - gemfire::CacheListener* ManagedCacheListenerGeneric::create( const char* assemblyPath, - const char* factoryFunctionName ) + namespace geode { - try + namespace client { - String^ mg_assemblyPath = - GemStone::GemFire::Cache::Generic::ManagedString::Get( assemblyPath ); - String^ mg_factoryFunctionName = - GemStone::GemFire::Cache::Generic::ManagedString::Get(factoryFunctionName); - String^ mg_typeName = nullptr; - - String^ mg_genericKey = nullptr; - String^ mg_genericVal = nullptr; - - int32_t dotIndx = -1; - int32_t genericsOpenIndx = -1; - int32_t genericsCloseIndx = -1; - int32_t commaIndx = -1; - - if (mg_factoryFunctionName == nullptr || - ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 ) + + apache::geode::client::CacheListener* ManagedCacheListenerGeneric::create(const char* assemblyPath, + const char* factoryFunctionName) { - std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; - ex_str += factoryFunctionName; - ex_str += "' does not contain type name"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try + { + String^ mg_assemblyPath = + GemStone::GemFire::Cache::Generic::ManagedString::Get(assemblyPath); + String^ mg_factoryFunctionName = + GemStone::GemFire::Cache::Generic::ManagedString::Get(factoryFunctionName); + String^ mg_typeName = nullptr; + + String^ mg_genericKey = nullptr; + String^ mg_genericVal = nullptr; + + int32_t dotIndx = -1; + int32_t genericsOpenIndx = -1; + int32_t genericsCloseIndx = -1; + int32_t commaIndx = -1; + + if (mg_factoryFunctionName == nullptr || + (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0) + { + std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; + ex_str += factoryFunctionName; + ex_str += "' does not contain type name"; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf('>')) < 0) + { + std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; + ex_str += factoryFunctionName; + ex_str += "' does not contain any generic type parameters"; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf('<')) < 0 || + genericsOpenIndx > genericsCloseIndx) + { + std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; + ex_str += factoryFunctionName; + ex_str += "' does not contain expected generic type parameters"; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + if ((commaIndx = mg_factoryFunctionName->LastIndexOf(',')) < 0 || + (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx)) + { + std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; + ex_str += factoryFunctionName; + ex_str += "' does not contain expected generic type parameter comma separator"; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName->Substring(0, genericsOpenIndx)); + mg_typeName = typeBuilder->ToString(); + mg_genericKey = mg_factoryFunctionName->Substring(genericsOpenIndx + 1, commaIndx - genericsOpenIndx - 1); + mg_genericKey = mg_genericKey->Trim(); + mg_genericVal = mg_factoryFunctionName->Substring(commaIndx + 1, genericsCloseIndx - commaIndx - 1); + mg_genericVal = mg_genericVal->Trim(); + mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1); + + GemStone::GemFire::Cache::Generic::Log::Fine("Attempting to instantiate a [{0}<{1}, {2}>] via the [{3}] factory method.", + mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName); + + typeBuilder->Append("`2"); + mg_typeName = typeBuilder->ToString(); + + Assembly^ assmb = nullptr; + try + { + assmb = Assembly::Load(mg_assemblyPath); + } + catch (System::Exception^) + { + assmb = nullptr; + } + if (assmb == nullptr) + { + std::string ex_str = "ManagedCacheListenerGeneric: Could not load assembly: "; + ex_str += assemblyPath; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + GemStone::GemFire::Cache::Generic::Log::Debug("Loading type: [{0}]", mg_typeName); + + Type^ typeInst = assmb->GetType(mg_typeName, false, true); + + if (typeInst != nullptr) + { + array<Type^>^ types = gcnew array<Type^>(2); + types[0] = Type::GetType(mg_genericKey, false, true); + types[1] = Type::GetType(mg_genericVal, false, true); + + if (types[0] == nullptr || types[1] == nullptr) + { + std::string ex_str = "ManagedCacheListenerGeneric: Could not get both generic type argument instances"; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + typeInst = typeInst->MakeGenericType(types); + GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName); + + MethodInfo^ mInfo = typeInst->GetMethod(mg_factoryFunctionName, + BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase); + + if (mInfo != nullptr) + { + Object^ userptr = nullptr; + try + { + userptr = mInfo->Invoke(typeInst, nullptr); + } + catch (System::Exception^ ex) + { + GemStone::GemFire::Cache::Generic::Log::Debug("{0}: {1}", ex->GetType()->Name, ex->Message); + userptr = nullptr; + } + if (userptr == nullptr) + { + std::string ex_str = "ManagedCacheListenerGeneric: Could not create " + "object on invoking factory function ["; + ex_str += factoryFunctionName; + ex_str += "] in assembly: "; + ex_str += assemblyPath; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + + ManagedCacheListenerGeneric * mgcl = new ManagedCacheListenerGeneric(userptr); + + Type^ clgType = Type::GetType("GemStone.GemFire.Cache.Generic.CacheListenerGeneric`2"); + clgType = clgType->MakeGenericType(types); + Object^ clg = Activator::CreateInstance(clgType); + + mInfo = clgType->GetMethod("SetCacheListener"); + array<Object^>^ params = gcnew array<Object^>(1); + params[0] = userptr; + mInfo->Invoke(clg, params); + + mgcl->setptr((GemStone::GemFire::Cache::Generic::ICacheListener<Object^, Object^>^)clg); + + return mgcl; + } + else + { + std::string ex_str = "ManagedCacheListenerGeneric: Could not load " + "function with name ["; + ex_str += factoryFunctionName; + ex_str += "] in assembly: "; + ex_str += assemblyPath; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + } + else + { + GemStone::GemFire::Cache::Generic::ManagedString typeName(mg_typeName); + std::string ex_str = "ManagedCacheListenerGeneric: Could not load type ["; + ex_str += typeName.CharPtr; + ex_str += "] in assembly: "; + ex_str += assemblyPath; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + } + catch (const apache::geode::client::Exception&) + { + throw; + } + catch (System::Exception^ ex) + { + GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString()); + std::string ex_str = "ManagedCacheListenerGeneric: Got an exception while " + "loading managed library: "; + ex_str += mg_exStr.CharPtr; + throw apache::geode::client::IllegalArgumentException(ex_str.c_str()); + } + return NULL; } - if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 ) + void ManagedCacheListenerGeneric::afterCreate(const apache::geode::client::EntryEvent& ev) { - std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; - ex_str += factoryFunctionName; - ex_str += "' does not contain any generic type parameters"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterCreate(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 || - genericsOpenIndx > genericsCloseIndx) + void ManagedCacheListenerGeneric::afterUpdate(const apache::geode::client::EntryEvent& ev) { - std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; - ex_str += factoryFunctionName; - ex_str += "' does not contain expected generic type parameters"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterUpdate(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - if ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 || - (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx)) + void ManagedCacheListenerGeneric::afterInvalidate(const apache::geode::client::EntryEvent& ev) { - std::string ex_str = "ManagedCacheListenerGeneric: Factory function name '"; - ex_str += factoryFunctionName; - ex_str += "' does not contain expected generic type parameter comma separator"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterInvalidate(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName->Substring(0, genericsOpenIndx)); - mg_typeName = typeBuilder->ToString(); - mg_genericKey = mg_factoryFunctionName->Substring(genericsOpenIndx + 1, commaIndx - genericsOpenIndx - 1); - mg_genericKey = mg_genericKey->Trim(); - mg_genericVal = mg_factoryFunctionName->Substring(commaIndx + 1, genericsCloseIndx - commaIndx - 1); - mg_genericVal = mg_genericVal->Trim(); - mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx + 1 ); - - GemStone::GemFire::Cache::Generic::Log::Fine("Attempting to instantiate a [{0}<{1}, {2}>] via the [{3}] factory method.", - mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName); - - typeBuilder->Append("`2"); - mg_typeName = typeBuilder->ToString(); - - Assembly^ assmb = nullptr; - try + void ManagedCacheListenerGeneric::afterDestroy(const apache::geode::client::EntryEvent& ev) { - assmb = Assembly::Load( mg_assemblyPath ); + try { + GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterDestroy(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - catch (System::Exception^) + void ManagedCacheListenerGeneric::afterRegionClear(const apache::geode::client::RegionEvent& ev) { - assmb = nullptr; + try { + GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterRegionClear(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - if (assmb == nullptr) + + void ManagedCacheListenerGeneric::afterRegionInvalidate(const apache::geode::client::RegionEvent& ev) { - std::string ex_str = "ManagedCacheListenerGeneric: Could not load assembly: "; - ex_str += assemblyPath; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterRegionInvalidate(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - GemStone::GemFire::Cache::Generic::Log::Debug("Loading type: [{0}]", mg_typeName); - - Type^ typeInst = assmb->GetType(mg_typeName, false, true); - - if (typeInst != nullptr) + void ManagedCacheListenerGeneric::afterRegionDestroy(const apache::geode::client::RegionEvent& ev) { - array<Type^>^ types = gcnew array<Type^>(2); - types[0] = Type::GetType(mg_genericKey, false, true); - types[1] = Type::GetType(mg_genericVal, false, true); - - if (types[0] == nullptr || types[1] == nullptr) - { - std::string ex_str = "ManagedCacheListenerGeneric: Could not get both generic type argument instances"; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterRegionDestroy(%mevent); } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } + } - typeInst = typeInst->MakeGenericType(types); - GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName); - - MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName, - BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase ); - - if (mInfo != nullptr) - { - Object^ userptr = nullptr; - try - { - userptr = mInfo->Invoke( typeInst, nullptr ); - } - catch (System::Exception^ ex) - { - GemStone::GemFire::Cache::Generic::Log::Debug("{0}: {1}", ex->GetType()->Name, ex->Message); - userptr = nullptr; - } - if (userptr == nullptr) - { - std::string ex_str = "ManagedCacheListenerGeneric: Could not create " - "object on invoking factory function ["; - ex_str += factoryFunctionName; - ex_str += "] in assembly: "; - ex_str += assemblyPath; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); - } - - ManagedCacheListenerGeneric * mgcl = new ManagedCacheListenerGeneric(userptr); - - Type^ clgType = Type::GetType("GemStone.GemFire.Cache.Generic.CacheListenerGeneric`2"); - clgType = clgType->MakeGenericType(types); - Object^ clg = Activator::CreateInstance(clgType); - - mInfo = clgType->GetMethod("SetCacheListener"); - array<Object^>^ params = gcnew array<Object^>(1); - params[0] = userptr; - mInfo->Invoke(clg, params); + void ManagedCacheListenerGeneric::afterRegionLive(const apache::geode::client::RegionEvent& ev) + { + try { + GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent(&ev); + m_managedptr->AfterRegionLive(%mevent); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } + } - mgcl->setptr((GemStone::GemFire::Cache::Generic::ICacheListener<Object^, Object^>^)clg); + void ManagedCacheListenerGeneric::close(const apache::geode::client::RegionPtr& region) + { + try { + GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ mregion = + GemStone::GemFire::Cache::Generic::Region<Object^, Object^>::Create(region.ptr()); - return mgcl; + m_managedptr->Close(mregion); } - else - { - std::string ex_str = "ManagedCacheListenerGeneric: Could not load " - "function with name ["; - ex_str += factoryFunctionName; - ex_str += "] in assembly: "; - ex_str += assemblyPath; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); } } - else + void ManagedCacheListenerGeneric::afterRegionDisconnected(const apache::geode::client::RegionPtr& region) { - GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName ); - std::string ex_str = "ManagedCacheListenerGeneric: Could not load type ["; - ex_str += typeName.CharPtr; - ex_str += "] in assembly: "; - ex_str += assemblyPath; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); + try { + GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ mregion = + GemStone::GemFire::Cache::Generic::Region<Object^, Object^>::Create(region.ptr()); + m_managedptr->AfterRegionDisconnected(mregion); + } + catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { + ex->ThrowNative(); + } + catch (System::Exception^ ex) { + GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); + } } - } - catch (const gemfire::Exception&) - { - throw; - } - catch (System::Exception^ ex) - { - GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) ); - std::string ex_str = "ManagedCacheListenerGeneric: Got an exception while " - "loading managed library: "; - ex_str += mg_exStr.CharPtr; - throw gemfire::IllegalArgumentException( ex_str.c_str( ) ); - } - return NULL; - } - - void ManagedCacheListenerGeneric::afterCreate( const gemfire::EntryEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterCreate( %mevent ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterUpdate( const gemfire::EntryEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterUpdate( %mevent ); - } - catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) { - ex->ThrowNative( ); - } - catch ( System::Exception^ ex ) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterInvalidate( const gemfire::EntryEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterInvalidate( %mevent ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterDestroy( const gemfire::EntryEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::EntryEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterDestroy( %mevent ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - void ManagedCacheListenerGeneric::afterRegionClear( const gemfire::RegionEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterRegionClear( %mevent ); - } - catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) { - ex->ThrowNative( ); - } - catch ( System::Exception^ ex ) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterRegionInvalidate( const gemfire::RegionEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterRegionInvalidate( %mevent ); - } - catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) { - ex->ThrowNative( ); - } - catch ( System::Exception^ ex ) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterRegionDestroy( const gemfire::RegionEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterRegionDestroy( %mevent ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::afterRegionLive( const gemfire::RegionEvent& ev ) - { - try { - GemStone::GemFire::Cache::Generic::RegionEvent<Object^, Object^> mevent( &ev ); - m_managedptr->AfterRegionLive( %mevent ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - - void ManagedCacheListenerGeneric::close( const gemfire::RegionPtr& region ) - { - try { - GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ mregion = - GemStone::GemFire::Cache::Generic::Region<Object^, Object^>::Create( region.ptr( ) ); - - m_managedptr->Close( mregion ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - void ManagedCacheListenerGeneric::afterRegionDisconnected( const gemfire::RegionPtr& region ) - { - try { - GemStone::GemFire::Cache::Generic::IRegion<Object^, Object^>^ mregion = - GemStone::GemFire::Cache::Generic::Region<Object^, Object^>::Create( region.ptr( ) ); - m_managedptr->AfterRegionDisconnected( mregion ); - } - catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) { - ex->ThrowNative(); - } - catch (System::Exception^ ex) { - GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex); - } - } - -} + + } // namespace client + } // namespace geode +} // namespace apache
