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/01/23 19:17:05 UTC
[13/50] [abbrv] geode git commit: GEODE-2316: Rename namespace
gemfire to apache::geode::client.
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.cpp b/src/clicache/src/impl/ManagedResultCollector.cpp
index 7be7470..66beb2f 100644
--- a/src/clicache/src/impl/ManagedResultCollector.cpp
+++ b/src/clicache/src/impl/ManagedResultCollector.cpp
@@ -32,192 +32,198 @@ using namespace System::Text;
using namespace System::Reflection;
-namespace gemfire
+namespace apache
{
-
- gemfire::ResultCollector* ManagedResultCollectorGeneric::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 dotIndx = -1;
- if (mg_factoryFunctionName == nullptr ||
- ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 )
+ apache::geode::client::ResultCollector* ManagedResultCollectorGeneric::create(const char* assemblyPath,
+ const char* factoryFunctionName)
{
- std::string ex_str = "ManagedResultCollector: 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;
+ Int32 dotIndx = -1;
- mg_typeName = mg_factoryFunctionName->Substring( 0, dotIndx );
- mg_factoryFunctionName = mg_factoryFunctionName->Substring( dotIndx + 1 );
+ if (mg_factoryFunctionName == nullptr ||
+ (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0)
+ {
+ std::string ex_str = "ManagedResultCollector: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain type name";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
- Assembly^ assmb = nullptr;
- try
- {
- assmb = Assembly::Load( mg_assemblyPath );
- }
- catch (System::Exception^)
- {
- assmb = nullptr;
- }
- if (assmb == nullptr)
- {
- std::string ex_str = "ManagedResultCollector: Could not load assembly: ";
- ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- Object^ typeInst = assmb->CreateInstance( mg_typeName, true );
- if (typeInst != nullptr)
- {
- MethodInfo^ mInfo = typeInst->GetType( )->GetMethod( mg_factoryFunctionName,
- BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase );
- if (mInfo != nullptr)
- {
- //GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^ managedptr = nullptr;
- Object^ userptr = nullptr;
+ mg_typeName = mg_factoryFunctionName->Substring(0, dotIndx);
+ mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1);
+
+ Assembly^ assmb = nullptr;
try
{
- throw gemfire::UnsupportedOperationException( "Not supported" );
- /*managedptr = dynamic_cast<GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^>(
- mInfo->Invoke( typeInst, nullptr ) );*/
- userptr = mInfo->Invoke( typeInst, nullptr );
+ assmb = Assembly::Load(mg_assemblyPath);
}
- catch (System::Exception^ ex)
+ catch (System::Exception^)
{
- GemStone::GemFire::Cache::Generic::Log::Debug("{0}: {1}", ex->GetType()->Name, ex->Message);
- userptr = nullptr;
+ assmb = nullptr;
}
- if (userptr == nullptr)
+ if (assmb == nullptr)
{
- std::string ex_str = "ManagedResultCollector: Could not create "
- "object on invoking factory function [";
- ex_str += factoryFunctionName;
+ std::string ex_str = "ManagedResultCollector: Could not load assembly: ";
+ ex_str += assemblyPath;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ Object^ typeInst = assmb->CreateInstance(mg_typeName, true);
+ if (typeInst != nullptr)
+ {
+ MethodInfo^ mInfo = typeInst->GetType()->GetMethod(mg_factoryFunctionName,
+ BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase);
+ if (mInfo != nullptr)
+ {
+ //GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^ managedptr = nullptr;
+ Object^ userptr = nullptr;
+ try
+ {
+ throw apache::geode::client::UnsupportedOperationException("Not supported");
+ /*managedptr = dynamic_cast<GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^>(
+ mInfo->Invoke( typeInst, nullptr ) );*/
+ 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 = "ManagedResultCollector: 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());
+ }
+ //TODO::need to pass proper pointer here
+ return new ManagedResultCollectorGeneric(/*(GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^) managedptr*/nullptr);
+ }
+ else
+ {
+ std::string ex_str = "ManagedResultCollector: 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 = "ManagedResultCollector: Could not load type [";
+ ex_str += typeName.CharPtr;
ex_str += "] in assembly: ";
ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
}
- //TODO::need to pass proper pointer here
- return new ManagedResultCollectorGeneric(/*(GemStone::GemFire::Cache::Generic::ResultCollector<Object^>^) managedptr*/nullptr );
}
- else
+ catch (const apache::geode::client::Exception&)
+ {
+ throw;
+ }
+ catch (System::Exception^ ex)
{
- std::string ex_str = "ManagedResultCollector: Could not load "
- "function with name [";
- ex_str += factoryFunctionName;
- ex_str += "] in assembly: ";
- ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedResultCollector: Got an exception while "
+ "loading managed library: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
}
+ return NULL;
}
- else
+
+ void ManagedResultCollectorGeneric::addResult(CacheablePtr& result)
{
- GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName );
- std::string ex_str = "ManagedResultCollector: 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::IGFSerializable^ res = SafeUMSerializableConvertGeneric(result.ptr());
+ Object^ rs = GemStone::GemFire::Cache::Generic::Serializable::GetManagedValueGeneric<Object^>(result);
+ m_managedptr->AddResult(rs);
+ //m_managedptr->AddResult( SafeUMSerializableConvert( result.ptr( ) ) );
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedResultCollector: Got an exception in"
+ "addResult: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
}
- }
- catch (const gemfire::Exception&)
- {
- throw;
- }
- catch (System::Exception^ ex)
- {
- GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
- std::string ex_str = "ManagedResultCollector: Got an exception while "
- "loading managed library: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- return NULL;
- }
-
- void ManagedResultCollectorGeneric::addResult(CacheablePtr& result )
- {
- try {
- //GemStone::GemFire::Cache::IGFSerializable^ res = SafeUMSerializableConvertGeneric(result.ptr());
- Object^ rs = GemStone::GemFire::Cache::Generic::Serializable::GetManagedValueGeneric<Object^>(result);
- m_managedptr->AddResult( rs );
- //m_managedptr->AddResult( SafeUMSerializableConvert( result.ptr( ) ) );
- }
- catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) {
- ex->ThrowNative( );
- }
- catch ( System::Exception^ ex ) {
- GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
- std::string ex_str = "ManagedResultCollector: Got an exception in"
- "addResult: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- }
- CacheableVectorPtr ManagedResultCollectorGeneric::getResult(uint32_t timeout)
- {
- try {
- //array<IGFSerializable^>^ rs = m_managedptr->GetResult(timeout);
- //gemfire::CacheableVectorPtr rsptr = gemfire::CacheableVector::create();
- //for( int index = 0; index < rs->Length; index++ )
- //{
- // //gemfire::CacheablePtr valueptr(GemStone::GemFire::Cache::Generic::Serializable::GetUnmanagedValueGeneric<IGFSerializable^>(rs[ index]));
- // gemfire::CacheablePtr valueptr (SafeMSerializableConvert(rs[ index]));
- // rsptr->push_back(valueptr);
- //}
- //return rsptr;
- throw gemfire::IllegalStateException( "This should not be get callled.");
- }
- catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) {
- ex->ThrowNative( );
- }
- catch ( System::Exception^ ex ) {
- GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
- std::string ex_str = "ManagedResultCollector: Got an exception in"
- "getResult: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- return NULLPTR;
- }
- void ManagedResultCollectorGeneric::endResults()
- {
- try {
- m_managedptr->EndResults();
- }
- catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) {
- ex->ThrowNative( );
- }
- catch ( System::Exception^ ex ) {
- GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
- std::string ex_str = "ManagedResultCollector: Got an exception in"
- "endResults: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- }
- void ManagedResultCollectorGeneric::clearResults()
- {
- try {
- m_managedptr->ClearResults(/*false*/);
- }
- catch ( GemStone::GemFire::Cache::Generic::GemFireException^ ex ) {
- ex->ThrowNative( );
- }
- catch ( System::Exception^ ex ) {
- GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
- std::string ex_str = "ManagedResultCollector: Got an exception in"
- "clearResults: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- }
-}
+ CacheableVectorPtr ManagedResultCollectorGeneric::getResult(uint32_t timeout)
+ {
+ try {
+ //array<IGFSerializable^>^ rs = m_managedptr->GetResult(timeout);
+ //apache::geode::client::CacheableVectorPtr rsptr = apache::geode::client::CacheableVector::create();
+ //for( int index = 0; index < rs->Length; index++ )
+ //{
+ // //apache::geode::client::CacheablePtr valueptr(GemStone::GemFire::Cache::Generic::Serializable::GetUnmanagedValueGeneric<IGFSerializable^>(rs[ index]));
+ // apache::geode::client::CacheablePtr valueptr (SafeMSerializableConvert(rs[ index]));
+ // rsptr->push_back(valueptr);
+ //}
+ //return rsptr;
+ throw apache::geode::client::IllegalStateException("This should not be get callled.");
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedResultCollector: Got an exception in"
+ "getResult: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ return NULLPTR;
+ }
+ void ManagedResultCollectorGeneric::endResults()
+ {
+ try {
+ m_managedptr->EndResults();
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedResultCollector: Got an exception in"
+ "endResults: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ void ManagedResultCollectorGeneric::clearResults()
+ {
+ try {
+ m_managedptr->ClearResults(/*false*/);
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedResultCollector: Got an exception in"
+ "clearResults: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedResultCollector.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.hpp b/src/clicache/src/impl/ManagedResultCollector.hpp
index dae03fd..09749e2 100644
--- a/src/clicache/src/impl/ManagedResultCollector.hpp
+++ b/src/clicache/src/impl/ManagedResultCollector.hpp
@@ -25,79 +25,83 @@
#include "ResultCollectorProxy.hpp"
#include "SafeConvert.hpp"
//#include "SafeConvert.hpp"
-//using namespace gemfire;
+//using namespace apache::geode::client;
-//using namespace gemfire;
-namespace gemfire {
+//using namespace apache::geode::client;
+namespace apache {
+ namespace geode {
+ namespace client {
- /// <summary>
- /// Wraps the managed <see cref="GemStone.GemFire.Cache.IResultCollector" />
- /// object and implements the native <c>gemfire::ResultCollector</c> interface.
- /// </summary>
- class ManagedResultCollectorGeneric
- : public gemfire::ResultCollector
- {
- public:
+ /// <summary>
+ /// Wraps the managed <see cref="GemStone.GemFire.Cache.IResultCollector" />
+ /// object and implements the native <c>apache::geode::client::ResultCollector</c> interface.
+ /// </summary>
+ class ManagedResultCollectorGeneric
+ : public apache::geode::client::ResultCollector
+ {
+ public:
- /// <summary>
- /// Constructor to initialize with the provided managed object.
- /// </summary>
- /// <param name="userptr">
- /// The managed object.
- /// </param>
- inline ManagedResultCollectorGeneric( GemStone::GemFire::Cache::Generic::ResultCollectorG^ userptr )
- : m_managedptr(userptr) { }
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="userptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedResultCollectorGeneric(GemStone::GemFire::Cache::Generic::ResultCollectorG^ userptr)
+ : m_managedptr(userptr) { }
- /// <summary>
- /// Static function to create a <c>ManagedResultCollector</c> using given
- /// managed assembly path and given factory function.
- /// </summary>
- /// <param name="assemblyPath">
- /// The path of the managed assembly that contains the <c>ICacheListener</c>
- /// factory function.
- /// </param>
- /// <param name="factoryFunctionName">
- /// The name of the factory function of the managed class for creating
- /// an object that implements <c>IResultCollector</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 gemfire::ResultCollector* create( const char* assemblyPath,
- const char* factoryFunctionName );
+ /// <summary>
+ /// Static function to create a <c>ManagedResultCollector</c> using given
+ /// managed assembly path and given factory function.
+ /// </summary>
+ /// <param name="assemblyPath">
+ /// The path of the managed assembly that contains the <c>ICacheListener</c>
+ /// factory function.
+ /// </param>
+ /// <param name="factoryFunctionName">
+ /// The name of the factory function of the managed class for creating
+ /// an object that implements <c>IResultCollector</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 apache::geode::client::ResultCollector* create(const char* assemblyPath,
+ const char* factoryFunctionName);
- /// <summary>
- /// Destructor -- does nothing.
- /// </summary>
- virtual ~ManagedResultCollectorGeneric( ) { }
+ /// <summary>
+ /// Destructor -- does nothing.
+ /// </summary>
+ virtual ~ManagedResultCollectorGeneric() { }
- CacheableVectorPtr getResult(uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
- void addResult(CacheablePtr& result);
- void endResults();
- void clearResults();
- /// <summary>
- /// Returns the wrapped managed object reference.
- /// </summary>
- inline GemStone::GemFire::Cache::Generic::ResultCollectorG^ ptr( ) const
- {
- return m_managedptr;
- }
+ CacheableVectorPtr getResult(uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
+ void addResult(CacheablePtr& result);
+ void endResults();
+ void clearResults();
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline GemStone::GemFire::Cache::Generic::ResultCollectorG^ ptr() const
+ {
+ return m_managedptr;
+ }
-
- private:
+ private:
- /// <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 ICacheListener
- /// 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::ResultCollectorG^> m_managedptr;
- //GemStone::GemFire::Cache::IResultCollector^ m_managedptr;
- //gcroot<Object^> m_userptr;
- };
-}
+ /// <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 ICacheListener
+ /// 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::ResultCollectorG^> m_managedptr;
+ //GemStone::GemFire::Cache::IResultCollector^ m_managedptr;
+ //gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.cpp b/src/clicache/src/impl/ManagedTransactionListener.cpp
index 4a4ffc4..cf7b117 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.cpp
@@ -30,227 +30,234 @@ using namespace System::Text;
using namespace System::Reflection;
-namespace gemfire
+namespace apache
{
-
- gemfire::TransactionListener* ManagedTransactionListenerGeneric::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;
+ apache::geode::client::TransactionListener* ManagedTransactionListenerGeneric::create( const char* assemblyPath,
+ const char* factoryFunctionName )
+ {
+ 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;
- int32_t genericsOpenIndx = -1;
- int32_t genericsCloseIndx = -1;
- int32_t commaIndx = -1;
+ String^ mg_genericKey = nullptr;
+ String^ mg_genericVal = nullptr;
- if (mg_factoryFunctionName == nullptr ||
- ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 )
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain type name";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
+ int32_t dotIndx = -1;
+ int32_t genericsOpenIndx = -1;
+ int32_t genericsCloseIndx = -1;
+ int32_t commaIndx = -1;
- if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain any generic type parameters";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
+ if (mg_factoryFunctionName == nullptr ||
+ ( dotIndx = mg_factoryFunctionName->LastIndexOf( '.' ) ) < 0 )
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain type name";
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
- if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
- genericsOpenIndx > genericsCloseIndx)
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain expected generic type parameters";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
+ if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: 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 ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
- (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain expected generic type parameter comma separator";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
+ if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
+ genericsOpenIndx > genericsCloseIndx)
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain expected generic type parameters";
+ 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 );
+ if ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
+ (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: 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( ) );
+ }
- 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);
+ 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 );
- typeBuilder->Append("`2");
- mg_typeName = typeBuilder->ToString();
+ 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);
- Assembly^ assmb = nullptr;
- try
- {
- assmb = Assembly::Load( mg_assemblyPath );
- }
- catch (System::Exception^)
- {
- assmb = nullptr;
- }
- if (assmb == nullptr)
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Could not load assembly: ";
- ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
+ typeBuilder->Append("`2");
+ mg_typeName = typeBuilder->ToString();
- GemStone::GemFire::Cache::Generic::Log::Debug("Loading type: [{0}]", mg_typeName);
+ Assembly^ assmb = nullptr;
+ try
+ {
+ assmb = Assembly::Load( mg_assemblyPath );
+ }
+ catch (System::Exception^)
+ {
+ assmb = nullptr;
+ }
+ if (assmb == nullptr)
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: Could not load assembly: ";
+ ex_str += assemblyPath;
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
- Type^ typeInst = assmb->GetType(mg_typeName, false, true);
+ GemStone::GemFire::Cache::Generic::Log::Debug("Loading type: [{0}]", mg_typeName);
- 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);
+ Type^ typeInst = assmb->GetType(mg_typeName, false, true);
- if (types[0] == nullptr || types[1] == nullptr)
- {
- std::string ex_str = "ManagedTransactionListenerGeneric: Could not get both generic type argument instances";
- throw gemfire::IllegalArgumentException( 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);
- typeInst = typeInst->MakeGenericType(types);
- GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
+ if (types[0] == nullptr || types[1] == nullptr)
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: Could not get both generic type argument instances";
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
- MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
- BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase );
+ typeInst = typeInst->MakeGenericType(types);
+ GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
- 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;
+ 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 = "ManagedTransactionListenerGeneric: 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( ) );
+ }
+ return new ManagedTransactionListenerGeneric( userptr );
+ }
+ else
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: 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( ) );
+ }
}
- if (userptr == nullptr)
+ else
{
- std::string ex_str = "ManagedTransactionListenerGeneric: Could not create "
- "object on invoking factory function [";
- ex_str += factoryFunctionName;
+ GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName );
+ std::string ex_str = "ManagedTransactionListenerGeneric: Could not load type [";
+ ex_str += typeName.CharPtr;
ex_str += "] in assembly: ";
ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
}
- return new ManagedTransactionListenerGeneric( userptr );
}
- else
+ catch (const apache::geode::client::Exception&)
{
- std::string ex_str = "ManagedTransactionListenerGeneric: Could not load "
- "function with name [";
- ex_str += factoryFunctionName;
- ex_str += "] in assembly: ";
- ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ throw;
}
+ catch (System::Exception^ ex)
+ {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
+ std::string ex_str = "ManagedTransactionListenerGeneric: Got an exception while "
+ "loading managed library: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
+ return NULL;
}
- else
+ void ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr& te )
{
- GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName );
- std::string ex_str = "ManagedTransactionListenerGeneric: 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::Log::Error("ManagedTransactionListenerGeneric::afterCommit in" );
+ GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
+ m_managedptr->AfterCommit( %mevent );
+ GemStone::GemFire::Cache::Generic::Log::Error("ManagedTransactionListenerGeneric::afterCommit in" );
+
+ }
+ 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 = "ManagedTransactionListenerGeneric: Got an exception while "
- "loading managed library: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- return NULL;
- }
- void ManagedTransactionListenerGeneric::afterCommit(gemfire::TransactionEventPtr& te )
- {
- try {
- GemStone::GemFire::Cache::Generic::Log::Error("ManagedTransactionListenerGeneric::afterCommit in" );
- GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
- m_managedptr->AfterCommit( %mevent );
- GemStone::GemFire::Cache::Generic::Log::Error("ManagedTransactionListenerGeneric::afterCommit in" );
-
- }
- catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
- ex->ThrowNative();
- }
- catch (System::Exception^ ex) {
- GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex);
- }
- }
- void ManagedTransactionListenerGeneric::afterFailedCommit(gemfire::TransactionEventPtr& te )
- {
- try {
- GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
- m_managedptr->AfterFailedCommit( %mevent );
- }
- catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
- ex->ThrowNative();
- }
- catch (System::Exception^ ex) {
- GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex);
- }
- }
- void ManagedTransactionListenerGeneric::afterRollback(gemfire::TransactionEventPtr& te )
- {
- try {
- GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
- m_managedptr->AfterRollback( %mevent );
- }
- catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
- ex->ThrowNative();
- }
- catch (System::Exception^ ex) {
- GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex);
- }
- }
- void ManagedTransactionListenerGeneric::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);
- }
- }
+ void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te )
+ {
+ try {
+ GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
+ m_managedptr->AfterFailedCommit( %mevent );
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex);
+ }
+ }
+ void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te )
+ {
+ try {
+ GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
+ m_managedptr->AfterRollback( %mevent );
+ }
+ catch (GemStone::GemFire::Cache::Generic::GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemStone::GemFire::Cache::Generic::GemFireException::ThrowNative(ex);
+ }
+ }
+ void ManagedTransactionListenerGeneric::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
-}
#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedTransactionListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.hpp b/src/clicache/src/impl/ManagedTransactionListener.hpp
index 76f680f..1ae8f6d 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.hpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.hpp
@@ -24,66 +24,70 @@
-namespace gemfire {
-
- /// <summary>
- /// Wraps the managed <see cref="GemStone.GemFire.Cache.ITransactionListener" />
- /// object and implements the native <c>gemfire::TransactionListener</c> interface.
- /// </summary>
- class ManagedTransactionListenerGeneric
- : public gemfire::TransactionListener
- {
- public:
-
- /// <summary>
- /// Constructor to initialize with the provided managed object.
- /// </summary>
- /// <param name="userptr">
- /// The managed object.
- /// </param>
- inline ManagedTransactionListenerGeneric(Object^ userptr )
- : m_userptr( userptr ) { }
-
- static gemfire::TransactionListener* create( const char* assemblyPath,
- const char* factoryFunctionName );
-
- virtual ~ManagedTransactionListenerGeneric( ) { }
-
- virtual void afterCommit(gemfire::TransactionEventPtr& te);
-
- virtual void afterFailedCommit(gemfire::TransactionEventPtr& te);
-
- virtual void afterRollback(gemfire::TransactionEventPtr& te);
-
- virtual void close();
-
- inline GemStone::GemFire::Cache::ITransactionListener^ ptr( ) const
- {
- return m_managedptr;
- }
-
- inline void setptr( GemStone::GemFire::Cache::ITransactionListener^ managedptr )
- {
- m_managedptr = managedptr;
- }
-
- inline Object^ userptr( ) const
- {
- return m_userptr;
- }
-
- private:
-
- /// <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 ITransactionListener
- /// 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::ITransactionListener^> m_managedptr;
-
- gcroot<Object^> m_userptr;
- };
-
-}
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="GemStone.GemFire.Cache.ITransactionListener" />
+ /// object and implements the native <c>apache::geode::client::TransactionListener</c> interface.
+ /// </summary>
+ class ManagedTransactionListenerGeneric
+ : public apache::geode::client::TransactionListener
+ {
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="userptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedTransactionListenerGeneric(Object^ userptr )
+ : m_userptr( userptr ) { }
+
+ static apache::geode::client::TransactionListener* create( const char* assemblyPath,
+ const char* factoryFunctionName );
+
+ virtual ~ManagedTransactionListenerGeneric( ) { }
+
+ virtual void afterCommit(apache::geode::client::TransactionEventPtr& te);
+
+ virtual void afterFailedCommit(apache::geode::client::TransactionEventPtr& te);
+
+ virtual void afterRollback(apache::geode::client::TransactionEventPtr& te);
+
+ virtual void close();
+
+ inline GemStone::GemFire::Cache::ITransactionListener^ ptr( ) const
+ {
+ return m_managedptr;
+ }
+
+ inline void setptr( GemStone::GemFire::Cache::ITransactionListener^ managedptr )
+ {
+ m_managedptr = managedptr;
+ }
+
+ inline Object^ userptr( ) const
+ {
+ return m_userptr;
+ }
+
+ private:
+
+ /// <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 ITransactionListener
+ /// 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::ITransactionListener^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.cpp b/src/clicache/src/impl/ManagedTransactionWriter.cpp
index f653cee..62b46e4 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -31,185 +31,192 @@ using namespace System::Reflection;
//using namespace GemStone::GemFire::Cache::Generic;
-namespace gemfire
+namespace apache
{
-
- gemfire::TransactionWriter* ManagedTransactionWriterGeneric::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 )
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain type name";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
-
- if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain any generic type parameters";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
-
- if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
- genericsOpenIndx > genericsCloseIndx)
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain expected generic type parameters";
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
-
- if ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
- (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
- ex_str += factoryFunctionName;
- ex_str += "' does not contain expected generic type parameter comma separator";
- throw gemfire::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^)
+ apache::geode::client::TransactionWriter* ManagedTransactionWriterGeneric::create( const char* assemblyPath,
+ const char* factoryFunctionName )
{
- assmb = nullptr;
- }
- if (assmb == nullptr)
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Could not load assembly: ";
- ex_str += assemblyPath;
- 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 = "ManagedTransactionWriterGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain type name";
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
- GemStone::GemFire::Cache::Generic::Log::Debug("Loading type: [{0}]", mg_typeName);
+ if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf( '>' )) < 0 )
+ {
+ std::string ex_str = "ManagedTransactionWriterGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain any generic type parameters";
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
- Type^ typeInst = assmb->GetType(mg_typeName, false, true);
+ if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf( '<' )) < 0 ||
+ genericsOpenIndx > genericsCloseIndx)
+ {
+ std::string ex_str = "ManagedTransactionWriterGeneric: 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 (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 ((commaIndx = mg_factoryFunctionName->LastIndexOf( ',' )) < 0 ||
+ (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
+ {
+ std::string ex_str = "ManagedTransactionWriterGeneric: 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( ) );
+ }
- if (types[0] == nullptr || types[1] == nullptr)
- {
- std::string ex_str = "ManagedTransactionWriterGeneric: Could not get both generic type argument instances";
- throw gemfire::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 );
- typeInst = typeInst->MakeGenericType(types);
- GemStone::GemFire::Cache::Generic::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
+ 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);
- MethodInfo^ mInfo = typeInst->GetMethod( mg_factoryFunctionName,
- BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase );
+ typeBuilder->Append("`2");
+ mg_typeName = typeBuilder->ToString();
- if (mInfo != nullptr)
- {
- Object^ userptr = nullptr;
+ Assembly^ assmb = nullptr;
try
{
- userptr = mInfo->Invoke( typeInst, nullptr );
+ assmb = Assembly::Load( mg_assemblyPath );
}
- catch (System::Exception^ ex)
+ catch (System::Exception^)
{
- GemStone::GemFire::Cache::Generic::Log::Debug("{0}: {1}", ex->GetType()->Name, ex->Message);
- userptr = nullptr;
+ assmb = nullptr;
}
- if (userptr == nullptr)
+ if (assmb == nullptr)
{
- std::string ex_str = "ManagedTransactionWriterGeneric: Could not create "
- "object on invoking factory function [";
- ex_str += factoryFunctionName;
+ std::string ex_str = "ManagedTransactionWriterGeneric: 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 = "ManagedTransactionWriterGeneric: 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 = "ManagedTransactionWriterGeneric: 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( ) );
+ }
+ return new ManagedTransactionWriterGeneric( userptr );
+ }
+ else
+ {
+ std::string ex_str = "ManagedTransactionWriterGeneric: 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 = "ManagedTransactionWriterGeneric: Could not load type [";
+ ex_str += typeName.CharPtr;
ex_str += "] in assembly: ";
ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
}
- return new ManagedTransactionWriterGeneric( userptr );
}
- else
+ catch (const apache::geode::client::Exception&)
{
- std::string ex_str = "ManagedTransactionWriterGeneric: Could not load "
- "function with name [";
- ex_str += factoryFunctionName;
- ex_str += "] in assembly: ";
- ex_str += assemblyPath;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
+ throw;
}
+ catch (System::Exception^ ex)
+ {
+ GemStone::GemFire::Cache::Generic::ManagedString mg_exStr( ex->ToString( ) );
+ std::string ex_str = "ManagedTransactionWriterGeneric: Got an exception while "
+ "loading managed library: ";
+ ex_str += mg_exStr.CharPtr;
+ throw apache::geode::client::IllegalArgumentException( ex_str.c_str( ) );
+ }
+ return NULL;
}
- else
+ void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te )
{
- GemStone::GemFire::Cache::Generic::ManagedString typeName( mg_typeName );
- std::string ex_str = "ManagedTransactionWriterGeneric: 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::TransactionEvent mevent( te.ptr() );
+ m_managedptr->BeforeCommit( %mevent );
+ }
+ 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 = "ManagedTransactionWriterGeneric: Got an exception while "
- "loading managed library: ";
- ex_str += mg_exStr.CharPtr;
- throw gemfire::IllegalArgumentException( ex_str.c_str( ) );
- }
- return NULL;
- }
- void ManagedTransactionWriterGeneric::beforeCommit(gemfire::TransactionEventPtr& te )
- {
- try {
- GemStone::GemFire::Cache::TransactionEvent mevent( te.ptr() );
- m_managedptr->BeforeCommit( %mevent );
- }
- 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
+
#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedTransactionWriter.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.hpp b/src/clicache/src/impl/ManagedTransactionWriter.hpp
index 81c6eaa..687b715 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.hpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.hpp
@@ -33,60 +33,64 @@ namespace GemStone {
}
}
-namespace gemfire {
-
- /// <summary>
- /// Wraps the managed <see cref="GemStone.GemFire.Cache.ITransactionWriter" />
- /// object and implements the native <c>gemfire::TransactionWriter</c> interface.
- /// </summary>
- class ManagedTransactionWriterGeneric
- : public gemfire::TransactionWriter
- {
- public:
-
- /// <summary>
- /// Constructor to initialize with the provided managed object.
- /// </summary>
- /// <param name="userptr">
- /// The managed object.
- /// </param>
- inline ManagedTransactionWriterGeneric(Object^ userptr )
- : m_userptr( userptr ) { }
-
- static gemfire::TransactionWriter* create( const char* assemblyPath,
- const char* factoryFunctionName );
-
- virtual ~ManagedTransactionWriterGeneric( ) { }
-
- virtual void beforeCommit(gemfire::TransactionEventPtr& te);
-
- inline GemStone::GemFire::Cache::ITransactionWriter^ ptr( ) const
- {
- return m_managedptr;
- }
-
- inline void setptr( GemStone::GemFire::Cache::ITransactionWriter^ managedptr )
- {
- m_managedptr = managedptr;
- }
-
- inline Object^ userptr( ) const
- {
- return m_userptr;
- }
-
- private:
-
- /// <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 ITransactionWriter
- /// 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::ITransactionWriter^> m_managedptr;
-
- gcroot<Object^> m_userptr;
- };
-
-}
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="GemStone.GemFire.Cache.ITransactionWriter" />
+ /// object and implements the native <c>apache::geode::client::TransactionWriter</c> interface.
+ /// </summary>
+ class ManagedTransactionWriterGeneric
+ : public apache::geode::client::TransactionWriter
+ {
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="userptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedTransactionWriterGeneric(Object^ userptr )
+ : m_userptr( userptr ) { }
+
+ static apache::geode::client::TransactionWriter* create( const char* assemblyPath,
+ const char* factoryFunctionName );
+
+ virtual ~ManagedTransactionWriterGeneric( ) { }
+
+ virtual void beforeCommit(apache::geode::client::TransactionEventPtr& te);
+
+ inline GemStone::GemFire::Cache::ITransactionWriter^ ptr( ) const
+ {
+ return m_managedptr;
+ }
+
+ inline void setptr( GemStone::GemFire::Cache::ITransactionWriter^ managedptr )
+ {
+ m_managedptr = managedptr;
+ }
+
+ inline Object^ userptr( ) const
+ {
+ return m_userptr;
+ }
+
+ private:
+
+ /// <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 ITransactionWriter
+ /// 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::ITransactionWriter^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
#endif
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedVisitor.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedVisitor.cpp b/src/clicache/src/impl/ManagedVisitor.cpp
index 2e29520..27ac920 100644
--- a/src/clicache/src/impl/ManagedVisitor.cpp
+++ b/src/clicache/src/impl/ManagedVisitor.cpp
@@ -23,24 +23,30 @@
using namespace System;
-namespace gemfire
+namespace apache
{
-
- void ManagedVisitorGeneric::visit( CacheableKeyPtr& key, CacheablePtr& value )
+ namespace geode
{
- using namespace GemStone::GemFire::Cache::Generic;
- try {
- ICacheableKey^ mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key.ptr()));
- IGFSerializable^ mg_value(SafeUMSerializableConvertGeneric(value.ptr()));
+ namespace client
+ {
+
+ void ManagedVisitorGeneric::visit(CacheableKeyPtr& key, CacheablePtr& value)
+ {
+ using namespace GemStone::GemFire::Cache::Generic;
+ try {
+ ICacheableKey^ mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key.ptr()));
+ IGFSerializable^ mg_value(SafeUMSerializableConvertGeneric(value.ptr()));
- m_visitor->Invoke( mg_key, (GemStone::GemFire::Cache::Generic::IGFSerializable^)mg_value );
- }
- catch (GemFireException^ ex) {
- ex->ThrowNative();
- }
- catch (System::Exception^ ex) {
- GemFireException::ThrowNative(ex);
- }
- }
+ m_visitor->Invoke(mg_key, (GemStone::GemFire::Cache::Generic::IGFSerializable^)mg_value);
+ }
+ catch (GemFireException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GemFireException::ThrowNative(ex);
+ }
+ }
-}
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/ManagedVisitor.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedVisitor.hpp b/src/clicache/src/impl/ManagedVisitor.hpp
index de14248..63ba803 100644
--- a/src/clicache/src/impl/ManagedVisitor.hpp
+++ b/src/clicache/src/impl/ManagedVisitor.hpp
@@ -22,55 +22,60 @@
#include <gfcpp/Properties.hpp>
#include "../Properties.hpp"
-//using namespace gemfire;
-namespace gemfire
+//using namespace apache::geode::client;
+namespace apache
{
-
- /// <summary>
- /// Wraps the managed <see cref="GemStone.GemFire.Cache.PropertyVisitor" />
- /// delegate and implements the native <c>gemfire::Properties::Visitor</c> interface.
- /// </summary>
- class ManagedVisitorGeneric
- : public gemfire::Properties::Visitor
+ namespace geode
{
- public:
+ namespace client
+ {
- /// <summary>
- /// Create a <c>gemfire::Properties::Visitor</c> from the given managed
- /// <c>PropertyVisitor</c> delegate.
- /// </summary>
- inline ManagedVisitorGeneric(Object^ visitorFunc) : m_managedptr( visitorFunc ) { }
+ /// <summary>
+ /// Wraps the managed <see cref="GemStone.GemFire.Cache.PropertyVisitor" />
+ /// delegate and implements the native <c>apache::geode::client::Properties::Visitor</c> interface.
+ /// </summary>
+ class ManagedVisitorGeneric
+ : public apache::geode::client::Properties::Visitor
+ {
+ public:
- /// <summary>
- /// Invokes the managed <c>PropertyVisitor</c> delegate for the given
- /// <c>Property</c> key and value.
- /// </summary>
- virtual void visit( CacheableKeyPtr& key, CacheablePtr& value );
+ /// <summary>
+ /// Create a <c>apache::geode::client::Properties::Visitor</c> from the given managed
+ /// <c>PropertyVisitor</c> delegate.
+ /// </summary>
+ inline ManagedVisitorGeneric(Object^ visitorFunc) : m_managedptr(visitorFunc) { }
- /// <summary>
- /// Destructor -- does nothing.
- /// </summary>
- virtual ~ManagedVisitorGeneric( ) { }
+ /// <summary>
+ /// Invokes the managed <c>PropertyVisitor</c> delegate for the given
+ /// <c>Property</c> key and value.
+ /// </summary>
+ virtual void visit(CacheableKeyPtr& key, CacheablePtr& value);
- void setptr(GemStone::GemFire::Cache::PropertyVisitor^ visitor)
- {
- m_visitor = visitor;
- }
+ /// <summary>
+ /// Destructor -- does nothing.
+ /// </summary>
+ virtual ~ManagedVisitorGeneric() { }
- private:
+ void setptr(GemStone::GemFire::Cache::PropertyVisitor^ visitor)
+ {
+ m_visitor = visitor;
+ }
- // 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 PropertyVisitor
- // 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.
- gcroot<Object^> m_managedptr;
+ private:
- gcroot<GemStone::GemFire::Cache::PropertyVisitor^> m_visitor;
+ // 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 PropertyVisitor
+ // 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.
+ gcroot<Object^> m_managedptr;
- // Disable the copy and assignment constructors
- ManagedVisitorGeneric( );
- ManagedVisitorGeneric( const ManagedVisitorGeneric& );
- };
+ gcroot<GemStone::GemFire::Cache::PropertyVisitor^> m_visitor;
-}
+ // Disable the copy and assignment constructors
+ ManagedVisitorGeneric();
+ ManagedVisitorGeneric(const ManagedVisitorGeneric&);
+ };
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/PartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PartitionResolver.hpp b/src/clicache/src/impl/PartitionResolver.hpp
index 2ef3b8c..ac8c2b8 100644
--- a/src/clicache/src/impl/PartitionResolver.hpp
+++ b/src/clicache/src/impl/PartitionResolver.hpp
@@ -37,7 +37,7 @@ namespace GemStone
public interface class IPartitionResolverProxy
{
public:
- gemfire::CacheableKeyPtr getRoutingObject(const gemfire::EntryEvent& ev);
+ apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev);
const char * getName();
};
@@ -55,7 +55,7 @@ namespace GemStone
m_resolver = resolver;
}
- 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);
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/PdxFieldType.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxFieldType.cpp b/src/clicache/src/impl/PdxFieldType.cpp
index 19c20fe..ff31733 100644
--- a/src/clicache/src/impl/PdxFieldType.cpp
+++ b/src/clicache/src/impl/PdxFieldType.cpp
@@ -168,7 +168,7 @@ namespace GemStone
case PdxTypes::SHORT:
case PdxTypes::CHAR:
- //case gemfire::GemfireTypeIds::CacheableChar: //TODO
+ //case apache::geode::client::GemfireTypeIds::CacheableChar: //TODO
return GemFireClassIds::CHAR_SIZE;
case PdxTypes::INT:
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/PdxInstanceImpl.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.cpp b/src/clicache/src/impl/PdxInstanceImpl.cpp
index effd7a1..d77ace8 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.cpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.cpp
@@ -53,7 +53,7 @@ namespace GemStone
m_pdxType->InitializeType();//to generate static position map
//need to initiailize stream. this will call todata and in toData we will have stream
- gemfire::DataOutput* output = gemfire::DataOutput::getDataOutput();
+ apache::geode::client::DataOutput* output = apache::geode::client::DataOutput::getDataOutput();
try
{
@@ -62,7 +62,7 @@ namespace GemStone
}
finally
{
- gemfire::DataOutput::releaseDataOutput(output);
+ apache::geode::client::DataOutput::releaseDataOutput(output);
}
}
@@ -994,7 +994,7 @@ namespace GemStone
uint8_t* copy = m_buffer;
if(!m_own)
- copy = gemfire::DataInput::getBufferCopy(m_buffer, m_bufferLength);
+ copy = apache::geode::client::DataInput::getBufferCopy(m_buffer, m_bufferLength);
DataInput^ dataInput = gcnew DataInput(copy, m_bufferLength);//this will delete buffer
dataInput->setPdxdeserialization(true);
@@ -1052,7 +1052,7 @@ namespace GemStone
if(m_own)
{
m_own = false;
- gemfire::DataOutput::safeDelete(m_buffer);
+ apache::geode::client::DataOutput::safeDelete(m_buffer);
}
}
http://git-wip-us.apache.org/repos/asf/geode/blob/e4fd74fb/src/clicache/src/impl/PdxInstanceImpl.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.hpp b/src/clicache/src/impl/PdxInstanceImpl.hpp
index eef2cad..a7b38a6 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.hpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.hpp
@@ -50,8 +50,8 @@ namespace GemStone
static array<SByte>^ Float_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0};
static array<SByte>^ Double_DefaultBytes = gcnew array<SByte>{0, 0, 0, 0, 0, 0, 0, 0};
static array<SByte>^ Date_DefaultBytes = gcnew array<SByte>{-1, -1, -1, -1, -1, -1, -1, -1};
- static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{gemfire::GemfireTypeIds::CacheableNullString};
- static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{gemfire::GemfireTypeIds::NullObj};
+ static array<SByte>^ String_DefaultBytes = gcnew array<SByte>{apache::geode::client::GemfireTypeIds::CacheableNullString};
+ static array<SByte>^ Object_DefaultBytes = gcnew array<SByte>{apache::geode::client::GemfireTypeIds::NullObj};
static array<SByte>^ NULL_ARRAY_DefaultBytes = gcnew array<SByte>{-1};
static PdxFieldType^ Default_PdxFieldType = gcnew PdxFieldType("default", "default", -1,