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/08/11 23:52:19 UTC
[03/52] [partial] geode-native git commit: GEODE-3165: Reogranized
sources relative to the root for better CMake IDE integration.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedPersistenceManager.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedPersistenceManager.cpp b/clicache/src/impl/ManagedPersistenceManager.cpp
new file mode 100644
index 0000000..5eeeeb4
--- /dev/null
+++ b/clicache/src/impl/ManagedPersistenceManager.cpp
@@ -0,0 +1,247 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "ManagedPersistenceManager.hpp"
+#include "../IPersistenceManager.hpp"
+
+#include <string>
+
+using namespace System;
+using namespace System::Text;
+using namespace System::Reflection;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ apache::geode::client::PersistenceManager* ManagedPersistenceManagerGeneric::create(const char* assemblyPath,
+ const char* factoryFunctionName)
+ {
+ try
+ {
+ String^ mg_assemblyPath = Apache::Geode::Client::ManagedString::Get(assemblyPath);
+ String^ mg_factoryFunctionName = Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
+ String^ mg_typeName = nullptr;
+
+ String^ mg_genericKey = nullptr;
+ String^ mg_genericVal = nullptr;
+
+ System::Int32 dotIndx = -1;
+ System::Int32 genericsOpenIndx = -1;
+ System::Int32 genericsCloseIndx = -1;
+ System::Int32 commaIndx = -1;
+
+ if (mg_factoryFunctionName == nullptr ||
+ (dotIndx = mg_factoryFunctionName->LastIndexOf('.')) < 0)
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain type name";
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+
+ if ((genericsCloseIndx = mg_factoryFunctionName->LastIndexOf('>')) < 0)
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain any generic type parameters";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ if ((genericsOpenIndx = mg_factoryFunctionName->LastIndexOf('<')) < 0 ||
+ genericsOpenIndx > genericsCloseIndx)
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain expected generic type parameters";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ if ((commaIndx = mg_factoryFunctionName->LastIndexOf(',')) < 0 ||
+ (commaIndx < genericsOpenIndx || commaIndx > genericsCloseIndx))
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Factory function name '";
+ ex_str += factoryFunctionName;
+ ex_str += "' does not contain expected generic type parameter comma separator";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ StringBuilder^ typeBuilder = gcnew StringBuilder(mg_factoryFunctionName->Substring(0, genericsOpenIndx));
+ mg_typeName = typeBuilder->ToString();
+ mg_genericKey = mg_factoryFunctionName->Substring(genericsOpenIndx + 1, commaIndx - genericsOpenIndx - 1);
+ mg_genericKey = mg_genericKey->Trim();
+ mg_genericVal = mg_factoryFunctionName->Substring(commaIndx + 1, genericsCloseIndx - commaIndx - 1);
+ mg_genericVal = mg_genericVal->Trim();
+ mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1);
+
+ Apache::Geode::Client::Log::Fine("Attempting to instantiate a [{0}<{1}, {2}>] via the [{3}] factory method.",
+ mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
+
+ typeBuilder->Append("`2");
+ mg_typeName = typeBuilder->ToString();
+
+ Assembly^ assmb = nullptr;
+ try
+ {
+ assmb = Assembly::Load(mg_assemblyPath);
+ }
+ catch (System::Exception^)
+ {
+ assmb = nullptr;
+ }
+ if (assmb == nullptr)
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Could not load assembly: ";
+ ex_str += assemblyPath;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+
+ Apache::Geode::Client::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 = "ManagedPersistenceManagerGeneric: Could not get both generic type argument instances";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ typeInst = typeInst->MakeGenericType(types);
+ Apache::Geode::Client::Log::Info("Loading function: [{0}]", mg_factoryFunctionName);
+
+ MethodInfo^ mInfo = typeInst->GetMethod(mg_factoryFunctionName,
+ BindingFlags::Public | BindingFlags::Static | BindingFlags::IgnoreCase);
+
+ if (mInfo != nullptr)
+ {
+ Object^ managedptr = nullptr;
+ try
+ {
+ managedptr = mInfo->Invoke(typeInst, nullptr);
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::Log::Debug("{0}: {1}", ex->GetType()->Name, ex->Message);
+ managedptr = nullptr;
+ }
+ if (managedptr == nullptr)
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Could not create "
+ "object on invoking factory function [";
+ ex_str += factoryFunctionName;
+ ex_str += "] in assembly: ";
+ ex_str += assemblyPath;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+
+ ManagedPersistenceManagerGeneric* mgcl = new ManagedPersistenceManagerGeneric(managedptr);
+
+ Type^ clgType = Type::GetType("Apache.Geode.Client.PersistenceManagerGeneric`2");
+ clgType = clgType->MakeGenericType(types);
+ Object^ clg = Activator::CreateInstance(clgType);
+
+ mInfo = clgType->GetMethod("SetPersistenceManager");
+ array<Object^>^ params = gcnew array<Object^>(1);
+ params[0] = managedptr;
+ mInfo->Invoke(clg, params);
+
+ mgcl->setptr((Apache::Geode::Client::IPersistenceManagerProxy^)clg);
+
+ return mgcl;
+ }
+ else
+ {
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Could not load "
+ "function with name [";
+ ex_str += factoryFunctionName;
+ ex_str += "] in assembly: ";
+ ex_str += assemblyPath;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ else
+ {
+ Apache::Geode::Client::ManagedString typeName(mg_typeName);
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Could not load type [";
+ ex_str += typeName.CharPtr;
+ ex_str += "] in assembly: ";
+ ex_str += assemblyPath;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ catch (const apache::geode::client::Exception&)
+ {
+ throw;
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::ManagedString mg_exStr(ex->ToString());
+ std::string ex_str = "ManagedPersistenceManagerGeneric: Got an exception while "
+ "loading managed library: ";
+ ex_str += mg_exStr.CharPtr;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+ return NULL;
+ }
+
+
+ void ManagedPersistenceManagerGeneric::write(const CacheableKeyPtr& key, const CacheablePtr& value, void *& PersistenceInfo)
+ {
+ m_managedptr->write(key, value);
+ }
+
+ bool ManagedPersistenceManagerGeneric::writeAll()
+ {
+ throw gcnew System::NotSupportedException;
+ }
+
+ void ManagedPersistenceManagerGeneric::init(const RegionPtr& region, PropertiesPtr& diskProperties)
+ {
+ m_managedptr->init(region, diskProperties);
+ }
+
+ CacheablePtr ManagedPersistenceManagerGeneric::read(const CacheableKeyPtr& key, void *& PersistenceInfo)
+ {
+ return m_managedptr->read(key);
+ }
+
+ bool ManagedPersistenceManagerGeneric::readAll()
+ {
+ throw gcnew System::NotSupportedException;
+ }
+
+ void ManagedPersistenceManagerGeneric::destroy(const CacheableKeyPtr& key, void *& PersistenceInfo)
+ {
+ m_managedptr->destroy(key);
+ }
+ void ManagedPersistenceManagerGeneric::close()
+ {
+ m_managedptr->close();
+ }
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedPersistenceManager.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedPersistenceManager.hpp b/clicache/src/impl/ManagedPersistenceManager.hpp
new file mode 100644
index 0000000..6f19e0a
--- /dev/null
+++ b/clicache/src/impl/ManagedPersistenceManager.hpp
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#pragma once
+#include "../geode_defs.hpp"
+#include <vcclr.h>
+#include "begin_native.hpp"
+#include <geode/PersistenceManager.hpp>
+#include "end_native.hpp"
+
+#include "PersistenceManagerProxy.hpp"
+
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.IPersistenceManager" />
+ /// object and implements the native <c>apache::geode::client::PersistenceManager</c> interface.
+ /// </summary>
+ class ManagedPersistenceManagerGeneric : public apache::geode::client::PersistenceManager
+ {
+ public:
+
+ inline ManagedPersistenceManagerGeneric(Object^ userptr) : m_userptr(userptr) { }
+
+ static apache::geode::client::PersistenceManager* create(const char* assemblyPath,
+ const char* factoryFunctionName);
+
+ virtual ~ManagedPersistenceManagerGeneric() { }
+
+
+ virtual void write(const CacheableKeyPtr& key, const CacheablePtr& value, void *& PersistenceInfo);
+ virtual bool writeAll();
+ virtual void init(const RegionPtr& region, PropertiesPtr& diskProperties);
+ virtual CacheablePtr read(const CacheableKeyPtr& key, void *& PersistenceInfo);
+ virtual bool readAll();
+ virtual void destroy(const CacheableKeyPtr& key, void *& PersistenceInfo);
+ virtual void close();
+
+ inline void setptr(Apache::Geode::Client::IPersistenceManagerProxy^ 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 IPersistenceManager
+ /// 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<Apache::Geode::Client::IPersistenceManagerProxy^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+
+ // Disable the copy and assignment constructors
+ ManagedPersistenceManagerGeneric(const ManagedPersistenceManagerGeneric&);
+ ManagedPersistenceManagerGeneric& operator = (const ManagedPersistenceManagerGeneric&);
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedResultCollector.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedResultCollector.cpp b/clicache/src/impl/ManagedResultCollector.cpp
new file mode 100644
index 0000000..91a353d
--- /dev/null
+++ b/clicache/src/impl/ManagedResultCollector.cpp
@@ -0,0 +1,227 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#include "../../geode_includes.hpp"
+//#include "../../../geode_includes.hpp"
+#include "ManagedResultCollector.hpp"
+//#include "../../../IGeodeSerializable.hpp"
+
+
+//#include "../IGeodeSerializable.hpp"
+#include "ManagedString.hpp"
+#include "SafeConvert.hpp"
+#include "../ExceptionTypes.hpp"
+#include <string>
+
+using namespace System;
+using namespace System::Text;
+using namespace System::Reflection;
+
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ apache::geode::client::ResultCollector* ManagedResultCollectorGeneric::create(const char* assemblyPath,
+ const char* factoryFunctionName)
+ {
+ try
+ {
+ String^ mg_assemblyPath =
+ Apache::Geode::Client::ManagedString::Get(assemblyPath);
+ String^ mg_factoryFunctionName =
+ Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
+ String^ mg_typeName = nullptr;
+ Int32 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());
+ }
+
+ mg_typeName = mg_factoryFunctionName->Substring(0, dotIndx);
+ mg_factoryFunctionName = mg_factoryFunctionName->Substring(dotIndx + 1);
+
+ 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 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)
+ {
+ //Apache::Geode::Client::ResultCollector<Object^>^ managedptr = nullptr;
+ Object^ userptr = nullptr;
+ try
+ {
+ throw apache::geode::client::UnsupportedOperationException("Not supported");
+ /*managedptr = dynamic_cast<Apache::Geode::Client::ResultCollector<Object^>^>(
+ mInfo->Invoke( typeInst, nullptr ) );*/
+ userptr = mInfo->Invoke(typeInst, nullptr);
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::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(/*(Apache::Geode::Client::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
+ {
+ Apache::Geode::Client::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 apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ catch (const apache::geode::client::Exception&)
+ {
+ throw;
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::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;
+ }
+
+ void ManagedResultCollectorGeneric::addResult(CacheablePtr& result)
+ {
+ try {
+ Object^ rs = Apache::Geode::Client::Serializable::GetManagedValueGeneric<Object^>(result);
+ m_managedptr->AddResult(rs);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::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());
+ }
+ }
+
+ CacheableVectorPtr ManagedResultCollectorGeneric::getResult(System::UInt32 timeout)
+ {
+ try {
+ //array<IGeodeSerializable^>^ 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(Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<IGeodeSerializable^>(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 (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::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 (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::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 (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::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-native/blob/6cbd424f/clicache/src/impl/ManagedResultCollector.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedResultCollector.hpp b/clicache/src/impl/ManagedResultCollector.hpp
new file mode 100644
index 0000000..3dd419e
--- /dev/null
+++ b/clicache/src/impl/ManagedResultCollector.hpp
@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include "../geode_defs.hpp"
+#include <vcclr.h>
+#include "begin_native.hpp"
+#include <geode/ResultCollector.hpp>
+#include "end_native.hpp"
+
+#include "ResultCollectorProxy.hpp"
+#include "SafeConvert.hpp"
+
+//using namespace apache::geode::client;
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.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(Apache::Geode::Client::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 apache::geode::client::ResultCollector* create(const char* assemblyPath,
+ const char* factoryFunctionName);
+
+ /// <summary>
+ /// Destructor -- does nothing.
+ /// </summary>
+ virtual ~ManagedResultCollectorGeneric() { }
+
+ CacheableVectorPtr getResult(System::UInt32 timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
+ void addResult(CacheablePtr& result);
+ void endResults();
+ void clearResults();
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::ResultCollectorG^ ptr() const
+ {
+ return m_managedptr;
+ }
+
+
+ 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<Apache::Geode::Client::ResultCollectorG^> m_managedptr;
+ //Apache::Geode::Client::IResultCollector^ m_managedptr;
+ //gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedString.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedString.hpp b/clicache/src/impl/ManagedString.hpp
new file mode 100644
index 0000000..ed67695
--- /dev/null
+++ b/clicache/src/impl/ManagedString.hpp
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+
+
+#include "../geode_defs.hpp"
+
+#ifdef _WIN32
+// FIXME: Why is this needed?
+//#define snprintf _snprintf
+#endif
+
+
+using namespace System;
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ ref class ManagedString sealed
+ {
+ private:
+
+ IntPtr m_str;
+
+
+ public:
+
+ // Constructors
+
+ inline ManagedString( String^ str )
+ {
+ m_str = (str == nullptr) ? IntPtr::Zero :
+ System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi( str );
+ }
+
+ // Destructor
+
+ inline ~ManagedString( )
+ {
+ if (m_str != IntPtr::Zero)
+ {
+ System::Runtime::InteropServices::Marshal::FreeHGlobal( m_str );
+ }
+ }
+
+ // The finalizer should normally never be called; either use non-pointer object
+ // or call delete explicitly.
+ !ManagedString( )
+ {
+ if (m_str != IntPtr::Zero)
+ {
+ System::Runtime::InteropServices::Marshal::FreeHGlobal( m_str );
+ }
+#if GF_DEVEL_ASSERTS == 1
+ throw gcnew System::ApplicationException(
+ "Finalizer for ManagedString should not have been called!!" );
+#endif
+ }
+
+ inline static String^ Get( const char* str )
+ {
+ return ((str == nullptr) ? nullptr : gcnew String( str ));
+ }
+
+ inline static String^ Get( const wchar_t* str )
+ {
+ return ((str == nullptr) ? nullptr : gcnew String( str ));
+ }
+
+ // Properties
+
+ property const char* CharPtr
+ {
+ inline const char* get( )
+ {
+ return ((m_str == IntPtr::Zero) ? nullptr :
+ static_cast<const char*>( m_str.ToPointer( ) ));
+ }
+ }
+ };
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedTransactionListener.cpp b/clicache/src/impl/ManagedTransactionListener.cpp
new file mode 100644
index 0000000..99a683b
--- /dev/null
+++ b/clicache/src/impl/ManagedTransactionListener.cpp
@@ -0,0 +1,263 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef CSTX_COMMENTED
+//#include "../geode_includes.hpp"
+#include "ManagedTransactionListener.hpp"
+//#include "../TransactionEvent.hpp"
+#include "../Log.hpp"
+//#include "../ITransactionListener.hpp"
+#include "ManagedString.hpp"
+#include "../ExceptionTypes.hpp"
+
+
+using namespace System;
+using namespace System::Text;
+using namespace System::Reflection;
+
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ apache::geode::client::TransactionListener* ManagedTransactionListenerGeneric::create(const char* assemblyPath,
+ const char* factoryFunctionName)
+ {
+ try
+ {
+ String^ mg_assemblyPath =
+ Apache::Geode::Client::ManagedString::Get(assemblyPath);
+ String^ mg_factoryFunctionName =
+ Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
+ String^ mg_typeName = nullptr;
+
+ String^ mg_genericKey = nullptr;
+ String^ mg_genericVal = nullptr;
+
+ System::Int32 dotIndx = -1;
+ System::Int32 genericsOpenIndx = -1;
+ System::Int32 genericsCloseIndx = -1;
+ System::Int32 commaIndx = -1;
+
+ 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 ((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 ((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());
+ }
+
+ 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());
+ }
+
+ 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);
+
+ Apache::Geode::Client::Log::Fine("Attempting to instantiate a [{0}<{1}, {2}>] via the [{3}] factory method.",
+ mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
+
+ typeBuilder->Append("`2");
+ mg_typeName = typeBuilder->ToString();
+
+ Assembly^ assmb = nullptr;
+ try
+ {
+ assmb = Assembly::Load(mg_assemblyPath);
+ }
+ catch (System::Exception^)
+ {
+ assmb = nullptr;
+ }
+ if (assmb == nullptr)
+ {
+ std::string ex_str = "ManagedTransactionListenerGeneric: Could not load assembly: ";
+ ex_str += assemblyPath;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ Apache::Geode::Client::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 = "ManagedTransactionListenerGeneric: Could not get both generic type argument instances";
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ typeInst = typeInst->MakeGenericType(types);
+ Apache::Geode::Client::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)
+ {
+ Apache::Geode::Client::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());
+ }
+ }
+ else
+ {
+ Apache::Geode::Client::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 apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ catch (const apache::geode::client::Exception&)
+ {
+ throw;
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::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;
+ }
+ void ManagedTransactionListenerGeneric::afterCommit(apache::geode::client::TransactionEventPtr& te)
+ {
+ try {
+ Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
+ Apache::Geode::Client::TransactionEvent mevent(te.get());
+ m_managedptr->AfterCommit(%mevent);
+ Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
+
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+ void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te)
+ {
+ try {
+ Apache::Geode::Client::TransactionEvent mevent(te.get());
+ m_managedptr->AfterFailedCommit(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+ void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te)
+ {
+ try {
+ Apache::Geode::Client::TransactionEvent mevent(te.get());
+ m_managedptr->AfterRollback(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+ void ManagedTransactionListenerGeneric::close()
+ {
+ try {
+ m_managedptr->Close();
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
+
+#endif
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedTransactionListener.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedTransactionListener.hpp b/clicache/src/impl/ManagedTransactionListener.hpp
new file mode 100644
index 0000000..cd48375
--- /dev/null
+++ b/clicache/src/impl/ManagedTransactionListener.hpp
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifdef CSTX_COMMENTED
+#pragma once
+
+#include "../geode_defs.hpp"
+#include <vcclr.h>
+#include <cppcache/TransactionListener.hpp>
+#include "../ITransactionListener.hpp"
+
+
+
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.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 Apache::Geode::Client::ITransactionListener^ ptr( ) const
+ {
+ return m_managedptr;
+ }
+
+ inline void setptr( Apache::Geode::Client::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<Apache::Geode::Client::ITransactionListener^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
+#endif
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedTransactionWriter.cpp b/clicache/src/impl/ManagedTransactionWriter.cpp
new file mode 100644
index 0000000..bde9cbe
--- /dev/null
+++ b/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef CSTX_COMMENTED
+//#include "../geode_includes.hpp"
+#include "ManagedTransactionWriter.hpp"
+//#include "../TransactionEvent.hpp"
+#include "../Log.hpp"
+#include "../ExceptionTypes.hpp"
+//#include "../ITransactionWriter.hpp"
+#include "ManagedString.hpp"
+
+
+using namespace System;
+using namespace System::Text;
+using namespace System::Reflection;
+
+//using namespace Apache::Geode::Client;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ apache::geode::client::TransactionWriter* ManagedTransactionWriterGeneric::create(const char* assemblyPath,
+ const char* factoryFunctionName)
+ {
+ try
+ {
+ String^ mg_assemblyPath =
+ Apache::Geode::Client::ManagedString::Get(assemblyPath);
+ String^ mg_factoryFunctionName =
+ Apache::Geode::Client::ManagedString::Get(factoryFunctionName);
+ String^ mg_typeName = nullptr;
+
+ String^ mg_genericKey = nullptr;
+ String^ mg_genericVal = nullptr;
+
+ System::Int32 dotIndx = -1;
+ System::Int32 genericsOpenIndx = -1;
+ System::Int32 genericsCloseIndx = -1;
+ System::Int32 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());
+ }
+
+ 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());
+ }
+
+ 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 ((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());
+ }
+
+ 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);
+
+ Apache::Geode::Client::Log::Fine("Attempting to instantiate a [{0}<{1}, {2}>] via the [{3}] factory method.",
+ mg_typeName, mg_genericKey, mg_genericVal, mg_factoryFunctionName);
+
+ typeBuilder->Append("`2");
+ mg_typeName = typeBuilder->ToString();
+
+ Assembly^ assmb = nullptr;
+ try
+ {
+ assmb = Assembly::Load(mg_assemblyPath);
+ }
+ catch (System::Exception^)
+ {
+ assmb = nullptr;
+ }
+ if (assmb == nullptr)
+ {
+ std::string ex_str = "ManagedTransactionWriterGeneric: Could not load assembly: ";
+ ex_str += assemblyPath;
+ throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+
+ Apache::Geode::Client::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);
+ Apache::Geode::Client::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)
+ {
+ Apache::Geode::Client::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
+ {
+ Apache::Geode::Client::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 apache::geode::client::IllegalArgumentException(ex_str.c_str());
+ }
+ }
+ catch (const apache::geode::client::Exception&)
+ {
+ throw;
+ }
+ catch (System::Exception^ ex)
+ {
+ Apache::Geode::Client::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;
+ }
+ void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te)
+ {
+ try {
+ Apache::Geode::Client::TransactionEvent mevent(te.get());
+ m_managedptr->BeforeCommit(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
+
+#endif
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedTransactionWriter.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedTransactionWriter.hpp b/clicache/src/impl/ManagedTransactionWriter.hpp
new file mode 100644
index 0000000..b4871cb
--- /dev/null
+++ b/clicache/src/impl/ManagedTransactionWriter.hpp
@@ -0,0 +1,96 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifdef CSTX_COMMENTED
+#pragma once
+
+#include "../geode_defs.hpp"
+#include <vcclr.h>
+#include <cppcache/TransactionWriter.hpp>
+#include "../ITransactionWriter.hpp"
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+interface class ITransactionWriter;
+ }
+ }
+}
+
+namespace apache {
+ namespace geode {
+ namespace client {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.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 Apache::Geode::Client::ITransactionWriter^ ptr( ) const
+ {
+ return m_managedptr;
+ }
+
+ inline void setptr( Apache::Geode::Client::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<Apache::Geode::Client::ITransactionWriter^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
+#endif
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedVisitor.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedVisitor.cpp b/clicache/src/impl/ManagedVisitor.cpp
new file mode 100644
index 0000000..3808ea8
--- /dev/null
+++ b/clicache/src/impl/ManagedVisitor.cpp
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#include "../../../../geode_includes.hpp"
+#include "ManagedVisitor.hpp"
+#include "SafeConvert.hpp"
+#include "../ExceptionTypes.hpp"
+
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ void ManagedVisitorGeneric::visit(CacheableKeyPtr& key, CacheablePtr& value)
+ {
+ using namespace Apache::Geode::Client;
+ try {
+ ICacheableKey^ mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key));
+ IGeodeSerializable^ mg_value(SafeUMSerializableConvertGeneric(value));
+
+ m_visitor->Invoke(mg_key, (Apache::Geode::Client::IGeodeSerializable^)mg_value);
+ }
+ catch (GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ GeodeException::ThrowNative(ex);
+ }
+ }
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedVisitor.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedVisitor.hpp b/clicache/src/impl/ManagedVisitor.hpp
new file mode 100644
index 0000000..a9f5947
--- /dev/null
+++ b/clicache/src/impl/ManagedVisitor.hpp
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "../geode_defs.hpp"
+#include <vcclr.h>
+#include "begin_native.hpp"
+#include <geode/Properties.hpp>
+#include "end_native.hpp"
+
+#include "../Properties.hpp"
+
+//using namespace apache::geode::client;
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.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>
+ /// 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>
+ /// 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>
+ /// Destructor -- does nothing.
+ /// </summary>
+ virtual ~ManagedVisitorGeneric() { }
+
+ void setptr(Apache::Geode::Client::PropertyVisitor^ visitor)
+ {
+ m_visitor = visitor;
+ }
+
+ private:
+
+ // 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;
+
+ gcroot<Apache::Geode::Client::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-native/blob/6cbd424f/clicache/src/impl/MemoryPressureHandler.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/MemoryPressureHandler.cpp b/clicache/src/impl/MemoryPressureHandler.cpp
new file mode 100644
index 0000000..080fa3a
--- /dev/null
+++ b/clicache/src/impl/MemoryPressureHandler.cpp
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../geode_includes.hpp"
+#include "MemoryPressureHandler.hpp"
+#include "windows.h"
+#include "psapi.h"
+#include "../Log.hpp"
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ System::Int64 g_prevUnmanagedSize = 0;
+
+ int MemoryPressureHandler::handle_timeout( const ACE_Time_Value&
+ current_time, const void* arg )
+ {
+ HANDLE hProcess = GetCurrentProcess( );
+
+ PROCESS_MEMORY_COUNTERS pmc;
+
+ if ( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) ) {
+ System::Int64 totalmem = (System::Int64)pmc.WorkingSetSize;
+ System::Int64 curr_managed_size = GC::GetTotalMemory( false );
+ System::Int64 curr_unmanagedMemory = totalmem - curr_managed_size;
+ Log::Finest( "Current total memory usage: {0}, managed memory: {1}, "
+ "unmanaged memory: {2}", totalmem, curr_managed_size,
+ curr_unmanagedMemory );
+ if ( curr_unmanagedMemory > 0 ) {
+ System::Int64 increase = curr_unmanagedMemory - g_prevUnmanagedSize;
+ if ( Math::Abs( increase ) > 20*1024*1024 ) {
+ if ( increase > 0 ) {
+ Log::Fine( "Adding memory pressure information to assist .NET GC: {0} bytes", increase );
+ GC::AddMemoryPressure( increase );
+ }
+ else {
+ Log::Fine( "Removing memory pressure information to assist .NET GC: {0} bytes", -increase );
+ GC::RemoveMemoryPressure( -increase );
+ }
+ g_prevUnmanagedSize = curr_unmanagedMemory;
+ }
+ }
+ }
+ else {
+ return -1;
+ }
+ return 0;
+ }
+
+ int MemoryPressureHandler::handle_close(ACE_HANDLE handle,
+ ACE_Reactor_Mask close_mask)
+ {
+ return 0;
+ }
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/MemoryPressureHandler.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/MemoryPressureHandler.hpp b/clicache/src/impl/MemoryPressureHandler.hpp
new file mode 100644
index 0000000..c8ac0e7
--- /dev/null
+++ b/clicache/src/impl/MemoryPressureHandler.hpp
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "begin_native.hpp"
+#include <geode/geode_globals.hpp>
+#include <ExpiryTaskManager.hpp>
+#include "end_native.hpp"
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ class MemoryPressureHandler
+ : public ACE_Event_Handler
+ {
+ public:
+ int handle_timeout( const ACE_Time_Value& current_time,
+ const void* arg );
+
+ int handle_close( ACE_HANDLE handle, ACE_Reactor_Mask close_mask );
+ };
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/PartitionResolver.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/PartitionResolver.hpp b/clicache/src/impl/PartitionResolver.hpp
new file mode 100644
index 0000000..8223e19
--- /dev/null
+++ b/clicache/src/impl/PartitionResolver.hpp
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+//#include "../geode_includes.hpp"
+//#include "../../../IPartitionResolver.hpp"
+#include "../IPartitionResolver.hpp"
+#include "../Region.hpp"
+#include "SafeConvert.hpp"
+#include "ManagedString.hpp"
+//#include "../../../Region.hpp"
+//#include "../../../Cache.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ public interface class IPartitionResolverProxy
+ {
+ public:
+ apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev);
+ const char * getName();
+ };
+
+ generic<class TKey, class TValue>
+ public ref class PartitionResolverGeneric : IPartitionResolverProxy
+ {
+ private:
+
+ IPartitionResolver<TKey, TValue>^ m_resolver;
+
+ public:
+
+ void SetPartitionResolver(IPartitionResolver<TKey, TValue>^ resolver)
+ {
+ m_resolver = resolver;
+ }
+
+ virtual apache::geode::client::CacheableKeyPtr getRoutingObject(const apache::geode::client::EntryEvent& ev)
+ {
+ EntryEvent<TKey, TValue> gevent(&ev);
+ Object^ groutingobject = m_resolver->GetRoutingObject(%gevent);
+ return Serializable::GetUnmanagedValueGeneric<Object^>(groutingobject, nullptr);
+ }
+
+ virtual const char * getName()
+ {
+ ManagedString mg_name(m_resolver->GetName());
+ return mg_name.CharPtr;
+ }
+ };
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/PdxFieldType.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/PdxFieldType.cpp b/clicache/src/impl/PdxFieldType.cpp
new file mode 100644
index 0000000..c319ccd
--- /dev/null
+++ b/clicache/src/impl/PdxFieldType.cpp
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include "PdxFieldType.hpp"
+#include "begin_native.hpp"
+#include <geode/GeodeTypeIds.hpp>
+#include "end_native.hpp"
+
+
+using namespace System;
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ namespace Internal
+ {
+ Int32 PdxFieldType::SequenceId::get()
+ {
+ return m_sequenceId;
+ }
+
+ String^ PdxFieldType::FieldName::get()
+ {
+ return m_fieldName;
+ }
+
+ String^ PdxFieldType::ClassName::get()
+ {
+ return m_className;
+ }
+
+ Byte PdxFieldType::TypeId::get()
+ {
+ return m_typeId;
+ }
+
+ bool PdxFieldType::IsVariableLengthType::get()
+ {
+ return m_isVariableLengthType;
+ }
+
+ Int32 PdxFieldType::Size::get()
+ {
+ return m_fixedSize;
+ }
+
+ Int32 PdxFieldType::VarLenFieldIdx::get()
+ {
+ return m_varLenFieldIdx;
+ }
+
+ Int32 PdxFieldType::VarLenOffsetIndex::get()
+ {
+ return m_vlOffsetIndex;
+ }
+
+ void PdxFieldType::VarLenOffsetIndex::set(Int32 val)
+ {
+ m_vlOffsetIndex = val;
+ }
+
+ Int32 PdxFieldType::RelativeOffset::get()
+ {
+ return m_relativeOffset;
+ }
+
+ void PdxFieldType::RelativeOffset::set(Int32 val)
+ {
+ m_relativeOffset = val;
+ }
+
+ //it compares fieldname and type-id
+ bool PdxFieldType::Equals(Object^ otherObj)
+ {
+ if (otherObj == nullptr)
+ return false;
+
+ PdxFieldType^ otherFieldType = dynamic_cast<PdxFieldType^>(otherObj);
+
+ if (otherFieldType == nullptr)
+ return false;
+
+ if (otherFieldType == this)
+ return true;
+
+ if (otherFieldType->m_fieldName == m_fieldName && otherFieldType->m_typeId == m_typeId)
+ return true;
+
+ return false;
+ }
+
+ Int32 PdxFieldType::GetHashCode()
+ {
+ int hash = m_cachedHashcode;
+ if (hash == 0)
+ {
+ if (m_fieldName != nullptr)
+ {
+ hash = hash * 31 + m_fieldName->GetHashCode();
+ }
+
+ hash = hash * 31 + m_typeId;
+ if (hash == 0)
+ hash = 1;
+ m_cachedHashcode = hash;
+ }
+
+ return m_cachedHashcode;
+ }
+
+ void PdxFieldType::ToData(DataOutput^ output)
+ {
+ output->WriteString(m_fieldName);
+ output->WriteInt32(m_sequenceId);
+ output->WriteInt32(m_varLenFieldIdx);
+ output->WriteByte(m_typeId);
+
+ output->WriteInt32(m_relativeOffset);
+ output->WriteInt32(m_vlOffsetIndex);
+ output->WriteBoolean(m_isIdentityField);
+ }
+
+ IGeodeSerializable^ PdxFieldType::FromData(DataInput^ input)
+ {
+ m_fieldName = input->ReadString();
+ m_sequenceId = input->ReadInt32();
+ m_varLenFieldIdx = input->ReadInt32();
+ m_typeId = input->ReadByte();
+
+ m_relativeOffset = input->ReadInt32();
+ m_vlOffsetIndex = input->ReadInt32();
+ m_isIdentityField = input->ReadBoolean();
+
+ m_fixedSize = getFixedTypeSize();
+
+ if (m_fixedSize != -1)
+ m_isVariableLengthType = false;
+ else
+ m_isVariableLengthType = true;
+
+ return this;
+ }
+
+ Int32 PdxFieldType::getFixedTypeSize()
+ {
+ switch (m_typeId)
+ {
+ case PdxTypes::BYTE:
+ case PdxTypes::BOOLEAN:
+ return GeodeClassIds::BOOLEAN_SIZE;
+
+ case PdxTypes::SHORT:
+ case PdxTypes::CHAR:
+ //case apache::geode::client::GeodeTypeIds::CacheableChar: //TODO
+ return GeodeClassIds::CHAR_SIZE;
+
+ case PdxTypes::INT:
+ case PdxTypes::FLOAT:
+ //case DSCODE.ENUM:
+ return GeodeClassIds::INTEGER_SIZE;
+
+ case PdxTypes::LONG:
+ case PdxTypes::DOUBLE:
+ case PdxTypes::DATE:
+ return GeodeClassIds::LONG_SIZE;
+
+ default:
+ return -1;
+ } // namespace Client
+ } // namespace Geode
+ } // namespace Apache
+
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/PdxFieldType.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/PdxFieldType.hpp b/clicache/src/impl/PdxFieldType.hpp
new file mode 100644
index 0000000..fdef59b
--- /dev/null
+++ b/clicache/src/impl/PdxFieldType.hpp
@@ -0,0 +1,150 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+using namespace System;
+#include "../DataOutput.hpp"
+#include "../DataInput.hpp"
+#include "../GeodeClassIds.hpp"
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ namespace Internal
+ {
+ public ref class PdxFieldType : IGeodeSerializable
+ {
+ private:
+ String^ m_fieldName;
+ String^ m_className;
+ Byte m_typeId;
+ Int32 m_sequenceId;
+ bool m_isVariableLengthType;
+ bool m_isIdentityField;
+ Int32 m_fixedSize;
+ Int32 m_varLenFieldIdx;
+
+ Int32 m_vlOffsetIndex;
+ Int32 m_relativeOffset;
+ Int32 m_cachedHashcode;
+ Int32 getFixedTypeSize();
+ public:
+ PdxFieldType(String^ fieldName,
+ String^ className,
+ Byte typeId,
+ Int32 sequenceId,
+ bool isVariableLengthType,
+ Int32 fixedSize,
+ Int32 varLenFieldIdx)
+ {
+ m_cachedHashcode = 0;
+ m_fieldName = fieldName;
+ m_className = className;
+ m_typeId = typeId;
+ m_sequenceId = sequenceId;//start with 0
+ m_isVariableLengthType = isVariableLengthType;
+ m_fixedSize = fixedSize;
+ m_varLenFieldIdx = varLenFieldIdx;//start with 0
+ m_isIdentityField = false;
+ }
+
+ PdxFieldType()
+ {
+ m_cachedHashcode = 0;
+ }
+
+ property Int32 SequenceId
+ {
+ Int32 get();
+ }
+
+ property String^ FieldName
+ {
+ String^ get();
+ }
+
+ property String^ ClassName
+ {
+ String^ get();
+ }
+
+ property Byte TypeId
+ {
+ Byte get();
+ }
+
+ property bool IsVariableLengthType
+ {
+ bool get();
+ }
+
+ property bool IdentityField
+ {
+ bool get() { return m_isIdentityField; }
+ void set(bool value) { m_isIdentityField = value; }
+ }
+
+ property Int32 Size
+ {
+ Int32 get();
+ }
+
+ property Int32 VarLenFieldIdx
+ {
+ Int32 get();
+ }
+
+ property Int32 VarLenOffsetIndex
+ {
+ Int32 get();
+ void set(Int32 Value);
+ }
+
+ property Int32 RelativeOffset
+ {
+ Int32 get();
+ void set(Int32 Value);
+ }
+
+ virtual bool Equals(Object^ otherObj) override;
+ virtual Int32 GetHashCode() override;
+
+ virtual void ToData(DataOutput^ output);
+ virtual IGeodeSerializable^ FromData(DataInput^ input);
+ virtual property System::UInt32 ObjectSize
+ {
+ System::UInt32 get(){ return 0; }
+ }
+ virtual property System::UInt32 ClassId
+ {
+ System::UInt32 get(){ return m_typeId; }
+ }
+ virtual String^ ToString() override
+ {
+ return "PdxFieldName:" + m_fieldName + ", TypeId: " + m_typeId + ", VarLenFieldIdx:" + m_varLenFieldIdx + ", sequenceid:" + m_sequenceId;
+ }
+ };
+ } // namespace Client
+ } // namespace Geode
+ } // namespace Apache
+
+}