You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2017/05/17 17:50:16 UTC
[34/46] geode-native git commit: GEODE-2741: Remove custom shared
pointer from clicache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/RegionEvent.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEvent.cpp b/src/clicache/src/RegionEvent.cpp
index ff3bb9d..3ee64d2 100644
--- a/src/clicache/src/RegionEvent.cpp
+++ b/src/clicache/src/RegionEvent.cpp
@@ -15,7 +15,6 @@
* limitations under the License.
*/
-//#include "geode_includes.hpp"
#include "RegionEvent.hpp"
#include "Region.hpp"
#include "IGeodeSerializable.hpp"
@@ -30,42 +29,23 @@ namespace Apache
{
generic<class TKey, class TValue>
- RegionEvent<TKey, TValue>::RegionEvent(Client::IRegion<TKey, TValue>^ region,
- Object^ aCallbackArgument, bool remoteOrigin)
- : UMWrap( )
- {
- //TODO:: do we neeed this
- /*if ( region == nullptr ) {
- throw gcnew IllegalArgumentException( "RegionEvent.ctor(): "
- "null region passed" );
- }
-
- apache::geode::client::UserDataPtr callbackptr(SafeMSerializableConvert(
- aCallbackArgument));
-
- SetPtr(new apache::geode::client::RegionEvent(apache::geode::client::RegionPtr(region->_NativePtr),
- callbackptr, remoteOrigin), true);*/
- }
-
- generic<class TKey, class TValue>
IRegion<TKey, TValue>^ RegionEvent<TKey, TValue>::Region::get( )
{
- apache::geode::client::RegionPtr& regionptr( NativePtr->getRegion( ) );
-
- return Client::Region<TKey, TValue>::Create( regionptr.ptr( ) );
+ auto regionptr = m_nativeptr->getRegion( );
+ return Client::Region<TKey, TValue>::Create( regionptr );
}
generic<class TKey, class TValue>
Object^ RegionEvent<TKey, TValue>::CallbackArgument::get()
{
- apache::geode::client::UserDataPtr& valptr(NativePtr->getCallbackArgument());
+ apache::geode::client::UserDataPtr& valptr(m_nativeptr->getCallbackArgument());
return Serializable::GetManagedValueGeneric<Object^>( valptr );
}
generic<class TKey, class TValue>
bool RegionEvent<TKey, TValue>::RemoteOrigin::get( )
{
- return NativePtr->remoteOrigin( );
+ return m_nativeptr->remoteOrigin( );
} // namespace Client
} // namespace Geode
} // namespace Apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/RegionEvent.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionEvent.hpp b/src/clicache/src/RegionEvent.hpp
index 1d9f23d..7554c13 100644
--- a/src/clicache/src/RegionEvent.hpp
+++ b/src/clicache/src/RegionEvent.hpp
@@ -18,8 +18,10 @@
#pragma once
#include "geode_defs.hpp"
+#include "begin_native.hpp"
#include <geode/RegionEvent.hpp>
-//#include "impl/NativeWrapper.hpp"
+#include "end_native.hpp"
+
#include "IGeodeSerializable.hpp"
#include "IRegion.hpp"
#include "Region.hpp"
@@ -32,6 +34,7 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
//ref class Region;
@@ -40,20 +43,10 @@ namespace Apache
/// </summary>
generic<class TKey, class TValue>
public ref class RegionEvent sealed
- : public Client::Internal::UMWrap<apache::geode::client::RegionEvent>
{
public:
/// <summary>
- /// Constructor to create a <c>RegionEvent</c> for a given region.
- /// </summary>
- /// <exception cref="IllegalArgumentException">
- /// if region is null
- /// </exception>
- RegionEvent(IRegion<TKey, TValue>^ region, Object^ aCallbackArgument,
- bool remoteOrigin);
-
- /// <summary>
/// Return the region this event occurred in.
/// </summary>
property IRegion<TKey, TValue>^ Region
@@ -82,13 +75,22 @@ namespace Apache
internal:
+ const native::RegionEvent* GetNative()
+ {
+ return m_nativeptr;
+ }
+
/// <summary>
/// Internal constructor to wrap a native object pointer
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
- inline Apache::Geode::Client::RegionEvent<TKey, TValue>( const apache::geode::client::RegionEvent* nativeptr )
- : Apache::Geode::Client::Internal::UMWrap<apache::geode::client::RegionEvent>(
- const_cast<apache::geode::client::RegionEvent*>( nativeptr ), false ) { }
+ inline Apache::Geode::Client::RegionEvent<TKey, TValue>( const native::RegionEvent* nativeptr )
+ : m_nativeptr( nativeptr )
+ {
+ }
+
+ private:
+ const native::RegionEvent* m_nativeptr;
};
} // namespace Client
} // namespace Geode
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/RegionFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionFactory.cpp b/src/clicache/src/RegionFactory.cpp
index 93a5e7a..f662a7c 100644
--- a/src/clicache/src/RegionFactory.cpp
+++ b/src/clicache/src/RegionFactory.cpp
@@ -17,9 +17,7 @@
#pragma once
-//#include "geode_includes.hpp"
#include "RegionFactory.hpp"
-//#include "AttributesFactory.hpp"
#include "RegionAttributes.hpp"
#include "impl/SafeConvert.hpp"
@@ -49,6 +47,7 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
RegionFactory^ RegionFactory::SetCacheLoader( String^ libPath, String^ factoryFunctionName )
{
@@ -56,8 +55,14 @@ namespace Apache
ManagedString mg_libpath( libPath );
ManagedString mg_factoryFunctionName( factoryFunctionName );
- NativePtr->setCacheLoader( mg_libpath.CharPtr,
- mg_factoryFunctionName.CharPtr );
+ try
+ {
+ m_nativeptr->get()->setCacheLoader( mg_libpath.CharPtr, mg_factoryFunctionName.CharPtr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -67,8 +72,14 @@ namespace Apache
ManagedString mg_libpath( libPath );
ManagedString mg_factoryFunctionName( factoryFunctionName );
- NativePtr->setCacheWriter( mg_libpath.CharPtr,
- mg_factoryFunctionName.CharPtr );
+ try
+ {
+ m_nativeptr->get()->setCacheWriter( mg_libpath.CharPtr, mg_factoryFunctionName.CharPtr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -78,8 +89,14 @@ namespace Apache
ManagedString mg_libpath( libPath );
ManagedString mg_factoryFunctionName( factoryFunctionName );
- NativePtr->setCacheListener( mg_libpath.CharPtr,
- mg_factoryFunctionName.CharPtr );
+ try
+ {
+ m_nativeptr->get()->setCacheListener( mg_libpath.CharPtr, mg_factoryFunctionName.CharPtr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -89,8 +106,14 @@ namespace Apache
ManagedString mg_libpath( libPath );
ManagedString mg_factoryFunctionName( factoryFunctionName );
- NativePtr->setPartitionResolver( mg_libpath.CharPtr,
- mg_factoryFunctionName.CharPtr );
+ try
+ {
+ m_nativeptr->get()->setPartitionResolver( mg_libpath.CharPtr, mg_factoryFunctionName.CharPtr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -98,29 +121,53 @@ namespace Apache
RegionFactory^ RegionFactory::SetEntryIdleTimeout( ExpirationAction action, System::UInt32 idleTimeout )
{
- NativePtr->setEntryIdleTimeout(
- static_cast<apache::geode::client::ExpirationAction::Action>( action ), idleTimeout );
+ try
+ {
+ m_nativeptr->get()->setEntryIdleTimeout( static_cast<native::ExpirationAction::Action>( action ), idleTimeout );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetEntryTimeToLive( ExpirationAction action, System::UInt32 timeToLive )
{
- NativePtr->setEntryTimeToLive(
- static_cast<apache::geode::client::ExpirationAction::Action>( action ), timeToLive );
+ try
+ {
+ m_nativeptr->get()->setEntryTimeToLive(static_cast<native::ExpirationAction::Action>( action ), timeToLive );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetRegionIdleTimeout( ExpirationAction action, System::UInt32 idleTimeout )
{
- NativePtr->setRegionIdleTimeout(
- static_cast<apache::geode::client::ExpirationAction::Action>( action ), idleTimeout );
+ try
+ {
+ m_nativeptr->get()->setRegionIdleTimeout(static_cast<native::ExpirationAction::Action>( action ), idleTimeout );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetRegionTimeToLive( ExpirationAction action, System::UInt32 timeToLive )
{
- NativePtr->setRegionTimeToLive(
- static_cast<apache::geode::client::ExpirationAction::Action>( action ), timeToLive );
+ try
+ {
+ m_nativeptr->get()->setRegionTimeToLive(static_cast<native::ExpirationAction::Action>( action ), timeToLive );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -130,15 +177,21 @@ namespace Apache
RegionFactory^ RegionFactory::SetPersistenceManager( Client::IPersistenceManager<TKey, TValue>^ persistenceManager,
Properties<String^, String^>^ config)
{
- apache::geode::client::PersistenceManagerPtr persistenceManagerptr;
+ native::PersistenceManagerPtr persistenceManagerptr;
if ( persistenceManager != nullptr ) {
PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
clg->SetPersistenceManager(persistenceManager);
- persistenceManagerptr = new apache::geode::client::ManagedPersistenceManagerGeneric( /*clg,*/ persistenceManager);
- ((apache::geode::client::ManagedPersistenceManagerGeneric*)persistenceManagerptr.get())->setptr(clg);
+ persistenceManagerptr = std::shared_ptr<native::ManagedPersistenceManagerGeneric>(new native::ManagedPersistenceManagerGeneric(persistenceManager));
+ ((native::ManagedPersistenceManagerGeneric*)persistenceManagerptr.get())->setptr(clg);
+ }
+ try
+ {
+ m_nativeptr->get()->setPersistenceManager( persistenceManagerptr, config->GetNative() );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
}
- apache::geode::client::PropertiesPtr configptr(GetNativePtr<apache::geode::client::Properties>( config ) );
- NativePtr->setPersistenceManager( persistenceManagerptr, configptr );
return this;
}
@@ -160,12 +213,15 @@ namespace Apache
{
ManagedString mg_libpath( libPath );
ManagedString mg_factoryFunctionName( factoryFunctionName );
- //TODO:split
- apache::geode::client::PropertiesPtr configptr(
- GetNativePtr<apache::geode::client::Properties>( config ) );
- NativePtr->setPersistenceManager( mg_libpath.CharPtr,
- mg_factoryFunctionName.CharPtr, configptr );
+ try
+ {
+ m_nativeptr->get()->setPersistenceManager( mg_libpath.CharPtr, mg_factoryFunctionName.CharPtr, config->GetNative() );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -173,7 +229,14 @@ namespace Apache
{
ManagedString mg_poolName( poolName );
- NativePtr->setPoolName( mg_poolName.CharPtr );
+ try
+ {
+ m_nativeptr->get()->setPoolName( mg_poolName.CharPtr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
@@ -183,7 +246,14 @@ namespace Apache
{
_GF_MG_EXCEPTION_TRY2
- NativePtr->setInitialCapacity( initialCapacity );
+ try
+ {
+ m_nativeptr->get()->setInitialCapacity( initialCapacity );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
_GF_MG_EXCEPTION_CATCH_ALL2
@@ -193,7 +263,14 @@ namespace Apache
{
_GF_MG_EXCEPTION_TRY2
- NativePtr->setLoadFactor( loadFactor );
+ try
+ {
+ m_nativeptr->get()->setLoadFactor( loadFactor );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
_GF_MG_EXCEPTION_CATCH_ALL2
@@ -203,7 +280,14 @@ namespace Apache
{
_GF_MG_EXCEPTION_TRY2
- NativePtr->setConcurrencyLevel( concurrencyLevel );
+ try
+ {
+ m_nativeptr->get()->setConcurrencyLevel( concurrencyLevel );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
_GF_MG_EXCEPTION_CATCH_ALL2
@@ -211,32 +295,66 @@ namespace Apache
RegionFactory^ RegionFactory::SetLruEntriesLimit( System::UInt32 entriesLimit )
{
- NativePtr->setLruEntriesLimit( entriesLimit );
+ try
+ {
+ m_nativeptr->get()->setLruEntriesLimit( entriesLimit );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetDiskPolicy( DiskPolicyType diskPolicy )
{
- NativePtr->setDiskPolicy(
- static_cast<apache::geode::client::DiskPolicyType::PolicyType>( diskPolicy ) );
+ try
+ {
+ m_nativeptr->get()->setDiskPolicy(static_cast<native::DiskPolicyType::PolicyType>( diskPolicy ) );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetCachingEnabled( bool cachingEnabled )
{
- NativePtr->setCachingEnabled( cachingEnabled );
+ try
+ {
+ m_nativeptr->get()->setCachingEnabled( cachingEnabled );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetCloningEnabled( bool cloningEnabled )
{
- NativePtr->setCloningEnabled( cloningEnabled );
+ try
+ {
+ m_nativeptr->get()->setCloningEnabled( cloningEnabled );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
RegionFactory^ RegionFactory::SetConcurrencyChecksEnabled( bool concurrencyChecksEnabled )
{
- NativePtr->setConcurrencyChecksEnabled( concurrencyChecksEnabled );
+ try
+ {
+ m_nativeptr->get()->setConcurrencyChecksEnabled( concurrencyChecksEnabled );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
// NEW GENERIC APIs:
@@ -246,11 +364,16 @@ namespace Apache
{
_GF_MG_EXCEPTION_TRY2/* due to auto replace */
- ManagedString mg_name( regionName );
-
- apache::geode::client::RegionPtr& nativeptr( NativePtr->create(
- mg_name.CharPtr ) );
- return Client::Region<TKey,TValue>::Create( nativeptr.ptr( ) );
+ try
+ {
+ ManagedString mg_name( regionName );
+ auto nativeptr = m_nativeptr->get()->create( mg_name.CharPtr );
+ return Client::Region<TKey,TValue>::Create( nativeptr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
}
@@ -258,73 +381,101 @@ namespace Apache
generic <class TKey, class TValue>
RegionFactory^ RegionFactory::SetCacheLoader( Client::ICacheLoader<TKey, TValue>^ cacheLoader )
{
- apache::geode::client::CacheLoaderPtr loaderptr;
+ native::CacheLoaderPtr loaderptr;
if ( cacheLoader != nullptr ) {
CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
clg->SetCacheLoader(cacheLoader);
- loaderptr = new apache::geode::client::ManagedCacheLoaderGeneric( /*clg,*/ cacheLoader );
- ((apache::geode::client::ManagedCacheLoaderGeneric*)loaderptr.get())->setptr(clg);
+ loaderptr = std::shared_ptr<native::ManagedCacheLoaderGeneric>(new native::ManagedCacheLoaderGeneric(cacheLoader));
+ ((native::ManagedCacheLoaderGeneric*)loaderptr.get())->setptr(clg);
+ }
+ try
+ {
+ m_nativeptr->get()->setCacheLoader( loaderptr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
}
- NativePtr->setCacheLoader( loaderptr );
return this;
}
generic <class TKey, class TValue>
RegionFactory^ RegionFactory::SetCacheWriter( Client::ICacheWriter<TKey, TValue>^ cacheWriter )
{
- apache::geode::client::CacheWriterPtr writerptr;
+ native::CacheWriterPtr writerptr;
if ( cacheWriter != nullptr ) {
CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
cwg->SetCacheWriter(cacheWriter);
- writerptr = new apache::geode::client::ManagedCacheWriterGeneric( /*cwg,*/ cacheWriter );
- ((apache::geode::client::ManagedCacheWriterGeneric*)writerptr.get())->setptr(cwg);
+ writerptr = std::shared_ptr<native::ManagedCacheWriterGeneric>(new native::ManagedCacheWriterGeneric(cacheWriter));
+ ((native::ManagedCacheWriterGeneric*)writerptr.get())->setptr(cwg);
+ }
+ try
+ {
+ m_nativeptr->get()->setCacheWriter( writerptr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
}
- NativePtr->setCacheWriter( writerptr );
return this;
}
generic <class TKey, class TValue>
RegionFactory^ RegionFactory::SetCacheListener( Client::ICacheListener<TKey, TValue>^ cacheListener )
{
- apache::geode::client::CacheListenerPtr listenerptr;
+ native::CacheListenerPtr listenerptr;
if ( cacheListener != nullptr ) {
CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
clg->SetCacheListener(cacheListener);
- listenerptr = new apache::geode::client::ManagedCacheListenerGeneric( /*clg,*/ cacheListener );
- ((apache::geode::client::ManagedCacheListenerGeneric*)listenerptr.get())->setptr(clg);
+ listenerptr = std::shared_ptr<native::ManagedCacheListenerGeneric>(new native::ManagedCacheListenerGeneric(cacheListener));
+ ((native::ManagedCacheListenerGeneric*)listenerptr.get())->setptr(clg);
/*
- listenerptr = new apache::geode::client::ManagedCacheListenerGeneric(
+ listenerptr = new native::ManagedCacheListenerGeneric(
(Client::ICacheListener<Object^, Object^>^)cacheListener);
*/
}
- NativePtr->setCacheListener( listenerptr );
+ try
+ {
+ m_nativeptr->get()->setCacheListener( listenerptr );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
return this;
}
generic <class TKey, class TValue>
- RegionFactory^ RegionFactory::SetPartitionResolver( Client::IPartitionResolver<TKey, TValue>^ partitionresolver )
+ RegionFactory^ RegionFactory::SetPartitionResolver(Client::IPartitionResolver<TKey, TValue>^ partitionresolver)
{
- apache::geode::client::PartitionResolverPtr resolverptr;
- if ( partitionresolver != nullptr ) {
- Client::IFixedPartitionResolver<TKey, TValue>^ resolver =
+ native::PartitionResolverPtr resolverptr;
+ if (partitionresolver != nullptr) {
+ Client::IFixedPartitionResolver<TKey, TValue>^ resolver =
dynamic_cast<Client::IFixedPartitionResolver<TKey, TValue>^>(partitionresolver);
- if (resolver != nullptr) {
+ if (resolver != nullptr) {
FixedPartitionResolverGeneric<TKey, TValue>^ prg = gcnew FixedPartitionResolverGeneric<TKey, TValue>();
prg->SetPartitionResolver(resolver);
- resolverptr = new apache::geode::client::ManagedFixedPartitionResolverGeneric( resolver );
- ((apache::geode::client::ManagedFixedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
+ resolverptr = std::shared_ptr<native::ManagedFixedPartitionResolverGeneric>(new native::ManagedFixedPartitionResolverGeneric(resolver));
+ ((native::ManagedFixedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
}
- else {
+ else {
PartitionResolverGeneric<TKey, TValue>^ prg = gcnew PartitionResolverGeneric<TKey, TValue>();
prg->SetPartitionResolver(partitionresolver);
- resolverptr = new apache::geode::client::ManagedPartitionResolverGeneric( partitionresolver );
- ((apache::geode::client::ManagedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
- }
+ resolverptr = std::shared_ptr<native::ManagedPartitionResolverGeneric>(new native::ManagedPartitionResolverGeneric(partitionresolver));
+ ((native::ManagedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
+ }
+ }
+ try
+ {
+ m_nativeptr->get()->setPartitionResolver(resolverptr);
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
}
- NativePtr->setPartitionResolver( resolverptr );
return this;
+ }
} // namespace Client
} // namespace Geode
} // namespace Apache
-}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/RegionFactory.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionFactory.hpp b/src/clicache/src/RegionFactory.hpp
index 337e2da..af79747 100644
--- a/src/clicache/src/RegionFactory.hpp
+++ b/src/clicache/src/RegionFactory.hpp
@@ -18,12 +18,18 @@
#pragma once
#include "geode_defs.hpp"
+#include "begin_native.hpp"
#include <geode/AttributesFactory.hpp>
-//#include "impl/NativeWrapper.hpp"
+#include "end_native.hpp"
+
+
#include "ExpirationAction.hpp"
#include "DiskPolicyType.hpp"
//#include "ScopeType.hpp"
+#include "begin_native.hpp"
#include <geode/RegionFactory.hpp>
+#include "end_native.hpp"
+
#include "RegionShortcut.hpp"
#include "ICacheLoader.hpp"
@@ -46,12 +52,12 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
/// <summary>
/// This interface provides for the configuration and creation of instances of Region.
/// </summary>
public ref class RegionFactory sealed
- : public Internal::SBWrap<apache::geode::client::RegionFactory>
{
public:
/// <summary>
@@ -428,10 +434,15 @@ namespace Apache
/// <returns>
/// The managed wrapper object; null if the native pointer is null.
/// </returns>
- inline static RegionFactory^ Create( apache::geode::client::RegionFactory* nativeptr )
+ inline static RegionFactory^ Create(native::RegionFactoryPtr nativeptr )
{
- return ( nativeptr != nullptr ?
- gcnew RegionFactory( nativeptr ) : nullptr );
+ return __nullptr == nativeptr ? nullptr :
+ gcnew RegionFactory( nativeptr );
+ }
+
+ std::shared_ptr<native::RegionFactory> GetNative()
+ {
+ return m_nativeptr->get_shared_ptr();
}
private:
@@ -440,8 +451,12 @@ namespace Apache
/// Private constructor to wrap a native object pointer
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
- inline RegionFactory( apache::geode::client::RegionFactory* nativeptr )
- : Internal::SBWrap<apache::geode::client::RegionFactory>( nativeptr ) { }
+ inline RegionFactory(native::RegionFactoryPtr nativeptr )
+ {
+ m_nativeptr = gcnew native_shared_ptr<native::RegionFactory>(nativeptr);
+ }
+
+ native_shared_ptr<native::RegionFactory>^ m_nativeptr;
};
} // namespace Client
} // namespace Geode
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/ResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.cpp b/src/clicache/src/ResultCollector.cpp
index 13220eb..9b0e249 100644
--- a/src/clicache/src/ResultCollector.cpp
+++ b/src/clicache/src/ResultCollector.cpp
@@ -31,13 +31,22 @@ namespace Apache
namespace Client
{
+ namespace native = apache::geode::client;
+
generic<class TResult>
void ResultCollector<TResult>::AddResult( TResult rs )
{
_GF_MG_EXCEPTION_TRY2/* due to auto replace */
- apache::geode::client::Serializable * result = SafeGenericMSerializableConvert((IGeodeSerializable^)rs);
- NativePtr->addResult( result==NULL ? (nullptr) : (apache::geode::client::CacheablePtr(result)) );
+ try
+ {
+ auto result = std::shared_ptr<native::Cacheable>(SafeGenericMSerializableConvert((IGeodeSerializable^)rs));
+ m_nativeptr->get()->addResult(result);
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
}
@@ -52,17 +61,22 @@ namespace Apache
System::Collections::Generic::ICollection<TResult>^ ResultCollector<TResult>::GetResult(UInt32 timeout)
{
_GF_MG_EXCEPTION_TRY2/* due to auto replace */
- apache::geode::client::CacheableVectorPtr results = NativePtr->getResult(timeout);
- array<TResult>^ rs =
- gcnew array<TResult>( results->size( ) );
- for( System::Int32 index = 0; index < results->size( ); index++ )
- {
- apache::geode::client::CacheablePtr& nativeptr(results->operator[](index));
-
- rs[ index] = Serializable::GetManagedValueGeneric<TResult>( nativeptr);
- }
- ICollection<TResult>^ collectionlist = (ICollection<TResult>^)rs;
- return collectionlist;
+ try
+ {
+ auto results = m_nativeptr->get()->getResult(timeout);
+ auto rs = gcnew array<TResult>(results->size());
+ for (System::Int32 index = 0; index < results->size(); index++)
+ {
+ auto nativeptr = results->operator[](index);
+ rs[index] = Serializable::GetManagedValueGeneric<TResult>(nativeptr);
+ }
+ auto collectionlist = (ICollection<TResult>^)rs;
+ return collectionlist;
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
}
@@ -71,7 +85,14 @@ namespace Apache
void ResultCollector<TResult>::EndResults()
{
_GF_MG_EXCEPTION_TRY2/* due to auto replace */
- NativePtr->endResults();
+ try
+ {
+ m_nativeptr->get()->endResults();
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
}
@@ -79,10 +100,16 @@ namespace Apache
void ResultCollector<TResult>::ClearResults(/*bool*/)
{
_GF_MG_EXCEPTION_TRY2/* due to auto replace */
- NativePtr->clearResults();
+ try
+ {
+ m_nativeptr->get()->clearResults();
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
_GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
+ }
} // namespace Client
} // namespace Geode
} // namespace Apache
-
-} //namespace
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/ResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.hpp b/src/clicache/src/ResultCollector.hpp
index 3b8067d..f75ffdc 100644
--- a/src/clicache/src/ResultCollector.hpp
+++ b/src/clicache/src/ResultCollector.hpp
@@ -20,8 +20,11 @@
#include "geode_defs.hpp"
#include "IResultCollector.hpp"
+#include "begin_native.hpp"
#include <geode/ResultCollector.hpp>
-#include "impl/NativeWrapper.hpp"
+#include "end_native.hpp"
+
+#include "native_shared_ptr.hpp"
using namespace System;
@@ -33,6 +36,7 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
generic<class TResult>
interface class IResultCollector;
@@ -42,7 +46,7 @@ namespace Apache
/// </summary>
generic<class TResult>
public ref class ResultCollector
- : public Internal::SBWrap<apache::geode::client::ResultCollector>, public IResultCollector<TResult>
+ : public IResultCollector<TResult>
{
public:
@@ -74,45 +78,15 @@ namespace Apache
internal:
/// <summary>
- /// Default constructor.
- /// </summary>
- inline ResultCollector( ):
- SBWrap( ){ }
-
- //~ResultCollector<TKey>( ) { }
-
- /// <summary>
/// Internal constructor to wrap a native object pointer
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
- inline ResultCollector( apache::geode::client::ResultCollector* nativeptr ):
- SBWrap( nativeptr ){ }
-
- /// <summary>
- /// Used to assign the native Serializable pointer to a new object.
- /// </summary>
- /// <remarks>
- /// Note the order of preserveSB() and releaseSB(). This handles the
- /// corner case when <c>m_nativeptr</c> is same as <c>nativeptr</c>.
- /// </remarks>
- inline void AssignSPGeneric( apache::geode::client::ResultCollector* nativeptr )
+ inline ResultCollector( native::ResultCollectorPtr nativeptr )
{
- AssignPtr( nativeptr );
+ m_nativeptr = gcnew native_shared_ptr<native::ResultCollector>(nativeptr);
}
- /// <summary>
- /// Used to assign the native CqListener pointer to a new object.
- /// </summary>
- inline void SetSPGeneric( apache::geode::client::ResultCollector* nativeptr )
- {
- if ( nativeptr != nullptr ) {
- nativeptr->preserveSB( );
- }
- _SetNativePtr( nativeptr );
- }
-
- //void Silence_LNK2022_BUG() { };
-
+ native_shared_ptr<native::ResultCollector>^ m_nativeptr;
};
} // namespace Client
} // namespace Geode
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/ResultSet.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultSet.cpp b/src/clicache/src/ResultSet.cpp
index d3a83e7..8e512cc 100644
--- a/src/clicache/src/ResultSet.cpp
+++ b/src/clicache/src/ResultSet.cpp
@@ -34,44 +34,67 @@ namespace Apache
generic<class TResult>
bool ResultSet<TResult>::IsModifiable::get( )
{
- return NativePtr->isModifiable( );
+ try
+ {
+ return m_nativeptr->get()->isModifiable( );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
System::Int32 ResultSet<TResult>::Size::get( )
{
- return NativePtr->size( );
+ try
+ {
+ return m_nativeptr->get()->size( );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
- /*IGeodeSerializable^*/TResult ResultSet<TResult>::default::get( size_t index )
+ TResult ResultSet<TResult>::default::get( size_t index )
{
- //return SafeUMSerializableConvertGeneric(NativePtr->operator[](static_cast<System::Int32>(index)).get());
- return (Serializable::GetManagedValueGeneric<TResult>(NativePtr->operator[](static_cast<System::Int32>(index))));
+ try
+ {
+ return (Serializable::GetManagedValueGeneric<TResult>(m_nativeptr->get()->operator[](static_cast<System::Int32>(index))));
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
- SelectResultsIterator<TResult>^ ResultSet<TResult>::GetIterator( )
+ SelectResultsIterator<TResult>^ ResultSet<TResult>::GetIterator()
{
- apache::geode::client::SelectResultsIterator* nativeptr =
- new apache::geode::client::SelectResultsIterator( NativePtr->getIterator( ) );
-
- return SelectResultsIterator<TResult>::Create( nativeptr );
+ try
+ {
+ return SelectResultsIterator<TResult>::Create(std::make_unique<apache::geode::client::SelectResultsIterator>(
+ m_nativeptr->get()->getIterator()));
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
- System::Collections::Generic::IEnumerator</*IGeodeSerializable^*/TResult>^
- ResultSet<TResult>::GetEnumerator( )
+ System::Collections::Generic::IEnumerator<TResult>^ ResultSet<TResult>::GetEnumerator( )
{
return GetIterator( );
}
generic<class TResult>
- System::Collections::IEnumerator^ ResultSet<TResult>::GetIEnumerator( )
+ System::Collections::IEnumerator^ ResultSet<TResult>::GetIEnumerator()
{
- return GetIterator( );
+ return GetIterator();
+ }
} // namespace Client
} // namespace Geode
} // namespace Apache
-
- } //namespace
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/ResultSet.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultSet.hpp b/src/clicache/src/ResultSet.hpp
index e4990cc..bc64ede 100644
--- a/src/clicache/src/ResultSet.hpp
+++ b/src/clicache/src/ResultSet.hpp
@@ -18,8 +18,11 @@
#pragma once
#include "geode_defs.hpp"
+#include "begin_native.hpp"
#include <geode/ResultSet.hpp>
-#include "impl/NativeWrapper.hpp"
+#include "end_native.hpp"
+
+#include "native_shared_ptr.hpp"
#include "ISelectResults.hpp"
@@ -31,6 +34,7 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
interface class IGeodeSerializable;
@@ -43,7 +47,7 @@ namespace Apache
/// </summary>
generic<class TResult>
public ref class ResultSet sealed
- : public Internal::SBWrap<apache::geode::client::ResultSet>, public ISelectResults<TResult>
+ : public ISelectResults<TResult>
{
public:
@@ -97,9 +101,10 @@ namespace Apache
/// <returns>
/// The managed wrapper object; null if the native pointer is null.
/// </returns>
- inline static ResultSet<TResult>^ Create(apache::geode::client::ResultSet* nativeptr)
+ inline static ResultSet<TResult>^ Create(native::ResultSetPtr nativeptr)
{
- return (nativeptr != nullptr ? gcnew ResultSet(nativeptr) : nullptr);
+ return __nullptr == nativeptr ? nullptr :
+ gcnew ResultSet<TResult>( nativeptr );
}
@@ -112,8 +117,12 @@ namespace Apache
/// Private constructor to wrap a native object pointer
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
- inline ResultSet(apache::geode::client::ResultSet* nativeptr)
- : SBWrap(nativeptr) { }
+ inline ResultSet(native::ResultSetPtr nativeptr)
+ {
+ m_nativeptr = gcnew native_shared_ptr<native::ResultSet>(nativeptr);
+ }
+
+ native_shared_ptr<native::ResultSet>^ m_nativeptr;
};
} // namespace Client
} // namespace Geode
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/SelectResultsIterator.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SelectResultsIterator.cpp b/src/clicache/src/SelectResultsIterator.cpp
index 0a241e0..0ac7edc 100644
--- a/src/clicache/src/SelectResultsIterator.cpp
+++ b/src/clicache/src/SelectResultsIterator.cpp
@@ -15,51 +15,81 @@
* limitations under the License.
*/
-//#include "geode_includes.hpp"
#include "SelectResultsIterator.hpp"
-
#include "impl/SafeConvert.hpp"
-using namespace System;
namespace Apache
{
namespace Geode
{
namespace Client
{
+ using namespace System;
generic<class TResult>
- /*Apache::Geode::Client::IGeodeSerializable^*/TResult SelectResultsIterator<TResult>::Current::get( )
+ TResult SelectResultsIterator<TResult>::Current::get( )
{
- //return SafeUMSerializableConvertGeneric( NativePtr->current( ).ptr( ) );
- return Serializable::GetManagedValueGeneric<TResult>(NativePtr->current( ));
+ try
+ {
+ return Serializable::GetManagedValueGeneric<TResult>(m_nativeptr->get()->current( ));
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
bool SelectResultsIterator<TResult>::MoveNext( )
{
- return NativePtr->moveNext( );
+ try
+ {
+ return m_nativeptr->get()->moveNext( );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
void SelectResultsIterator<TResult>::Reset( )
{
- NativePtr->reset( );
+ try
+ {
+ m_nativeptr->get()->reset( );
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
- /*Apache::Geode::Client::IGeodeSerializable^*/TResult SelectResultsIterator<TResult>::Next( )
+ TResult SelectResultsIterator<TResult>::Next( )
{
- //return SafeUMSerializableConvertGeneric( NativePtr->next( ).ptr( ) );
- return Serializable::GetManagedValueGeneric<TResult>(NativePtr->next( ));
+ try
+ {
+ return Serializable::GetManagedValueGeneric<TResult>(m_nativeptr->get()->next( ));
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
}
generic<class TResult>
- bool SelectResultsIterator<TResult>::HasNext::get( )
+ bool SelectResultsIterator<TResult>::HasNext::get()
{
- return NativePtr->hasNext( );
+ try
+ {
+ return m_nativeptr->get()->hasNext();
+ }
+ finally
+ {
+ GC::KeepAlive(m_nativeptr);
+ }
+ }
} // namespace Client
} // namespace Geode
} // namespace Apache
-
- } //namespace
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6027574a/src/clicache/src/SelectResultsIterator.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/SelectResultsIterator.hpp b/src/clicache/src/SelectResultsIterator.hpp
index 1784529..0bb6191 100644
--- a/src/clicache/src/SelectResultsIterator.hpp
+++ b/src/clicache/src/SelectResultsIterator.hpp
@@ -18,8 +18,11 @@
#pragma once
#include "geode_defs.hpp"
+#include "begin_native.hpp"
#include <geode/SelectResultsIterator.hpp>
-#include "impl/NativeWrapper.hpp"
+#include "end_native.hpp"
+
+#include "native_unique_ptr.hpp"
using namespace System;
@@ -30,6 +33,7 @@ namespace Apache
{
namespace Client
{
+ namespace native = apache::geode::client;
interface class IGeodeSerializable;
@@ -38,8 +42,7 @@ namespace Apache
/// </summary>
generic<class TResult>
public ref class SelectResultsIterator sealed
- : public Internal::UMWrap<apache::geode::client::SelectResultsIterator>,
- public System::Collections::Generic::IEnumerator</*Apache::Geode::Client::IGeodeSerializable^*/TResult>
+ : public System::Collections::Generic::IEnumerator</*Apache::Geode::Client::IGeodeSerializable^*/TResult>
{
public:
@@ -85,6 +88,7 @@ namespace Apache
bool get( );
}
+ ~SelectResultsIterator() {};
internal:
@@ -97,10 +101,10 @@ namespace Apache
/// The managed wrapper object; null if the native pointer is null.
/// </returns>
inline static Apache::Geode::Client::SelectResultsIterator<TResult>^ Create(
- apache::geode::client::SelectResultsIterator* nativeptr )
+ std::unique_ptr<native::SelectResultsIterator> nativeptr )
{
return ( nativeptr != nullptr ?
- gcnew Apache::Geode::Client::SelectResultsIterator<TResult>( nativeptr ) : nullptr );
+ gcnew Apache::Geode::Client::SelectResultsIterator<TResult>( std::move(nativeptr) ) : nullptr );
}
@@ -120,8 +124,12 @@ namespace Apache
/// </summary>
/// <param name="nativeptr">The native object pointer</param>
inline SelectResultsIterator(
- apache::geode::client::SelectResultsIterator* nativeptr )
- : UMWrap( nativeptr, true ) { }
+ std::unique_ptr<native::SelectResultsIterator> nativeptr )
+ {
+ m_nativeptr = gcnew native_unique_ptr<native::SelectResultsIterator>(std::move(nativeptr));
+ }
+
+ native_unique_ptr<native::SelectResultsIterator>^ m_nativeptr;
};
} // namespace Client
} // namespace Geode