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:21 UTC
[05/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/ManagedCacheLoader.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheLoader.hpp b/clicache/src/impl/ManagedCacheLoader.hpp
new file mode 100644
index 0000000..4d09d49
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheLoader.hpp
@@ -0,0 +1,160 @@
+/*
+ * 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/CacheLoader.hpp>
+#include "end_native.hpp"
+
+
+#include "../ICacheLoader.hpp"
+#include "CacheLoader.hpp"
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.ICacheLoader" />
+ /// object and implements the native <c>apache::geode::client::CacheLoader</c> interface.
+ /// </summary>
+ class ManagedCacheLoaderGeneric
+ : public apache::geode::client::CacheLoader
+ {
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="userptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedCacheLoaderGeneric(
+ /*Generic::ICacheLoader<Object^, Object^>^ managedptr,*/ Object^ userptr)
+ : /*m_managedptr( managedptr ),*/ m_userptr(userptr) { }
+
+ /// <summary>
+ /// Static function to create a <c>ManagedCacheLoader</c> using given
+ /// managed assembly path and given factory function.
+ /// </summary>
+ /// <param name="assemblyPath">
+ /// The path of the managed assembly that contains the <c>ICacheLoader</c>
+ /// factory function.
+ /// </param>
+ /// <param name="factoryFunctionName">
+ /// The name of the factory function of the managed class for creating
+ /// an object that implements <c>ICacheLoader</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::CacheLoader* create(const char* assemblyPath,
+ const char* factoryFunctionName);
+
+ virtual ~ManagedCacheLoaderGeneric() { }
+
+ /// <summary>
+ /// Loads a value. Application writers should implement this
+ /// method to customize the loading of a value.
+ /// </summary>
+ /// <remarks>
+ /// This method is called by the caching service when the requested
+ /// value is not in the cache. Any exception thrown by this method
+ /// is propagated back to and thrown by the invocation of
+ /// <see cref="Apache.Geode.Client.Region.Get" /> that triggered this load.
+ /// </remarks>
+ /// <param name="region">a Region Pointer for which this is called.</param>
+ /// <param name="key">the key for the cacheable</param>
+ /// <param name="aCallbackArgument">any related user data, or null</param>
+ /// <returns>
+ /// the value supplied for this key, or null if no value can be
+ /// supplied.
+ /// If every available loader returns
+ /// a null value, <see cref="Apache.Geode.Client.Region.Get" />
+ /// will return null.
+ /// </returns>
+ /// <seealso cref="Apache.Geode.Client.Region.Get" />
+ virtual CacheablePtr load(const RegionPtr& region,
+ const CacheableKeyPtr& key, const UserDataPtr& aCallbackArgument);
+
+ /// <summary>
+ /// Called when the region containing this callback is destroyed, when
+ /// the cache is closed.
+ /// </summary>
+ /// <remarks>
+ /// Implementations should clean up any external
+ /// resources, such as database connections. Any runtime exceptions this method
+ /// throws will be logged.
+ /// <para>
+ /// It is possible for this method to be called multiple times on a single
+ /// callback instance, so implementations must be tolerant of this.
+ /// </para>
+ /// </remarks>
+ /// <param name="region">the region pointer</param>
+ /// <seealso cref="Apache.Geode.Client.Cache.Close" />
+ /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
+ virtual void close(const RegionPtr& region);
+
+ /*
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::ICacheLoader^ ptr( ) const
+ {
+ return m_managedptr;
+ }
+ */
+
+ inline void setptr(Apache::Geode::Client::ICacheLoaderProxy^ 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 ICacheLoader
+ /// to be called which is not what is desired when this object is destroyed. Normally this
+ /// managed object may be created by the user and will be handled automatically by the GC.
+ /// </summary>
+ gcroot<Apache::Geode::Client::ICacheLoaderProxy^> m_managedptr;
+
+ gcroot<Object^> m_userptr;
+
+ // Disable the copy and assignment constructors
+ ManagedCacheLoaderGeneric(const ManagedCacheLoaderGeneric&);
+ ManagedCacheLoaderGeneric& operator = (const ManagedCacheLoaderGeneric&);
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheWriter.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheWriter.cpp b/clicache/src/impl/ManagedCacheWriter.cpp
new file mode 100644
index 0000000..646cf7e
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheWriter.cpp
@@ -0,0 +1,316 @@
+/*
+ * 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 "ManagedCacheWriter.hpp"
+#include "../ICacheWriter.hpp"
+#include "../Region.hpp"
+#include "../RegionEvent.hpp"
+#include "../EntryEvent.hpp"
+#include "../Log.hpp"
+#include "ManagedString.hpp"
+#include "../ExceptionTypes.hpp"
+#include "SafeConvert.hpp"
+#include "CacheWriter.hpp"
+
+using namespace System;
+using namespace System::Text;
+using namespace System::Reflection;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ CacheWriter* ManagedCacheWriterGeneric::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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: Could not create "
+ "object on invoking factory function [";
+ ex_str += factoryFunctionName;
+ ex_str += "] in assembly: ";
+ ex_str += assemblyPath;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+ ManagedCacheWriterGeneric* mgcw = new ManagedCacheWriterGeneric(managedptr);
+
+ Type^ cwgType = Type::GetType("Apache.Geode.Client.CacheWriterGeneric`2");
+ cwgType = cwgType->MakeGenericType(types);
+ Object^ cwg = Activator::CreateInstance(cwgType);
+
+ mInfo = cwgType->GetMethod("SetCacheWriter");
+ array<Object^>^ params = gcnew array<Object^>(1);
+ params[0] = managedptr;
+ mInfo->Invoke(cwg, params);
+
+ mgcw->setptr((Apache::Geode::Client::ICacheWriter<Object^, Object^>^)cwg);
+
+ return mgcw;
+ }
+ else
+ {
+ std::string ex_str = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: 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 = "ManagedCacheWriterGeneric: Got an exception while "
+ "loading managed library: ";
+ ex_str += mg_exStr.CharPtr;
+ throw IllegalArgumentException(ex_str.c_str());
+ }
+ return NULL;
+ }
+
+ bool ManagedCacheWriterGeneric::beforeUpdate(const EntryEvent& ev)
+ {
+ try {
+ Apache::Geode::Client::EntryEvent<Object^, Object^> mevent(&ev);
+
+ return m_managedptr->BeforeUpdate(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ bool ManagedCacheWriterGeneric::beforeCreate(const EntryEvent& ev)
+ {
+ try {
+ Apache::Geode::Client::EntryEvent<Object^, Object^> mevent(&ev);
+
+ return m_managedptr->BeforeCreate(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ bool ManagedCacheWriterGeneric::beforeDestroy(const EntryEvent& ev)
+ {
+ try {
+ Apache::Geode::Client::EntryEvent<Object^, Object^> mevent(&ev);
+
+ return m_managedptr->BeforeDestroy(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+ bool ManagedCacheWriterGeneric::beforeRegionClear(const RegionEvent& ev)
+ {
+ try {
+ Apache::Geode::Client::RegionEvent<Object^, Object^> mevent(&ev);
+
+ return m_managedptr->BeforeRegionClear(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ bool ManagedCacheWriterGeneric::beforeRegionDestroy(const RegionEvent& ev)
+ {
+ try {
+ Apache::Geode::Client::RegionEvent<Object^, Object^> mevent(&ev);
+
+ return m_managedptr->BeforeRegionDestroy(%mevent);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ void ManagedCacheWriterGeneric::close(const RegionPtr& rp)
+ {
+ try {
+ Apache::Geode::Client::IRegion<Object^, Object^>^ mregion =
+ Apache::Geode::Client::Region<Object^, Object^>::Create(rp);
+
+ m_managedptr->Close(reinterpret_cast<Apache::Geode::Client::Region<Object^, Object^>^>(mregion));
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
+
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheWriter.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheWriter.hpp b/clicache/src/impl/ManagedCacheWriter.hpp
new file mode 100644
index 0000000..0b6eba1
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheWriter.hpp
@@ -0,0 +1,191 @@
+/*
+ * 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/CacheWriter.hpp>
+#include "end_native.hpp"
+
+#include "../ICacheWriter.hpp"
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.ICacheWriter" />
+ /// object and implements the native <c>apache::geode::client::CacheWriter</c> interface.
+ /// </summary>
+ class ManagedCacheWriterGeneric
+ : public CacheWriter
+ {
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="userptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedCacheWriterGeneric(Object^ userptr) : m_userptr(userptr) { }
+
+ /// <summary>
+ /// Static function to create a <c>ManagedCacheWriter</c> using given
+ /// managed assembly path and given factory function.
+ /// </summary>
+ /// <param name="assemblyPath">
+ /// The path of the managed assembly that contains the <c>ICacheWriter</c>
+ /// factory function.
+ /// </param>
+ /// <param name="factoryFunctionName">
+ /// The name of the factory function of the managed class for creating
+ /// an object that implements <c>ICacheWriter</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 CacheWriter* create(const char* assemblyPath,
+ const char* factoryFunctionName);
+
+ virtual ~ManagedCacheWriterGeneric() { }
+
+ /// <summary>
+ /// Called before an entry is updated. The entry update is initiated by a
+ /// <c>put</c> or a <c>get</c> that causes the loader to update an existing entry.
+ /// </summary>
+ /// <remarks>
+ /// The entry previously existed in the cache where the operation was
+ /// initiated, although the old value may have been null. The entry being
+ /// updated may or may not exist in the local cache where the CacheWriter is
+ /// installed.
+ /// </remarks>
+ /// <param name="ev">
+ /// EntryEvent denotes the event object associated with updating the entry
+ /// </param>
+ /// <seealso cref="Apache.Geode.Client.Region.Put" />
+ /// <seealso cref="Apache.Geode.Client.Region.Get" />
+ bool beforeUpdate(const EntryEvent& ev);
+
+ /// <summary>
+ /// Called before an entry is created. Entry creation is initiated by a
+ /// <c>create</c>, a <c>put</c>, or a <c>get</c>.
+ /// </summary>
+ /// <remarks>
+ /// The <c>CacheWriter</c> can determine whether this value comes from a
+ /// <c>get</c> or not from <c>load</c>. The entry being created may already
+ /// exist in the local cache where this <c>CacheWriter</c> is installed,
+ /// but it does not yet exist in the cache where the operation was initiated.
+ /// </remarks>
+ /// <param name="ev">
+ /// EntryEvent denotes the event object associated with creating the entry
+ /// </param>
+ /// <seealso cref="Apache.Geode.Client.Region.Create" />
+ /// <seealso cref="Apache.Geode.Client.Region.Put" />
+ /// <seealso cref="Apache.Geode.Client.Region.Get" />
+ bool beforeCreate(const EntryEvent& ev);
+
+ /// <summary>
+ /// Called before an entry is destroyed.
+ /// </summary>
+ /// <remarks>
+ /// The entry being destroyed may or may
+ /// not exist in the local cache where the CacheWriter is installed. This method
+ /// is <em>not</em> called as a result of expiration or
+ /// <see cref="Apache.Geode.Client.Region.LocalDestroyRegion" />.
+ /// </remarks>
+ /// <param name="ev">
+ /// EntryEvent denotes the event object associated with destroying the entry
+ /// </param>
+ /// <seealso cref="Apache.Geode.Client.Region.Destroy" />
+ bool beforeDestroy(const EntryEvent& ev);
+
+ /// <summary>
+ /// called before this region is cleared
+ /// </summary>
+ bool beforeRegionClear(const RegionEvent& ev);
+
+ /// <summary>
+ /// called before this region is destroyed
+ /// </summary>
+ /// <param name="ev">
+ /// RegionEvent denotes the event object associated with destroying the region
+ /// </param>
+ /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
+ bool beforeRegionDestroy(const RegionEvent& ev);
+
+ /// <summary>
+ /// Called when the region containing this callback is destroyed, when
+ /// the cache is closed.
+ /// </summary>
+ /// <remarks>
+ /// Implementations should clean up any external
+ /// resources, such as database connections. Any runtime exceptions this method
+ /// throws will be logged.
+ /// <para>
+ /// It is possible for this method to be called multiple times on a single
+ /// callback instance, so implementations must be tolerant of this.
+ /// </para>
+ /// </remarks>
+ /// <seealso cref="Apache.Geode.Client.Cache.Close" />
+ /// <seealso cref="Apache.Geode.Client.Region.DestroyRegion" />
+ void close(const RegionPtr& rp);
+
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::ICacheWriter<Object^, Object^>^ ptr() const
+ {
+ return m_managedptr;
+ }
+
+ inline void setptr(Apache::Geode::Client::ICacheWriter<Object^, Object^>^ 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 ICacheWriter
+ /// 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::ICacheWriter<Object^, Object^>^> 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/ManagedCacheableDelta.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableDelta.cpp b/clicache/src/impl/ManagedCacheableDelta.cpp
new file mode 100644
index 0000000..8c0c0d1
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableDelta.cpp
@@ -0,0 +1,282 @@
+/*
+ * 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 "begin_native.hpp"
+#include <GeodeTypeIdsImpl.hpp>
+#include "end_native.hpp"
+
+#include "ManagedCacheableDelta.hpp"
+#include "../DataInput.hpp"
+#include "../DataOutput.hpp"
+#include "../CacheableString.hpp"
+#include "../ExceptionTypes.hpp"
+#include "SafeConvert.hpp"
+
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ void ManagedCacheableDeltaGeneric::toData(DataOutput& output) const
+ {
+ try {
+ System::UInt32 pos = (int)output.getBufferLength();
+ Apache::Geode::Client::DataOutput mg_output(&output, true);
+ m_managedSerializableptr->ToData(%mg_output);
+ //this will move the cursor in c++ layer
+ mg_output.WriteBytesToUMDataOutput();
+ ManagedCacheableDeltaGeneric* tmp = const_cast<ManagedCacheableDeltaGeneric*>(this);
+ tmp->m_objectSize = (int)(output.getBufferLength() - pos);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ Serializable* ManagedCacheableDeltaGeneric::fromData(DataInput& input)
+ {
+ try {
+ int pos = input.getBytesRead();
+ Apache::Geode::Client::DataInput mg_input(&input, true, input.getCache());
+ m_managedSerializableptr->FromData(%mg_input);
+
+ //this will move the cursor in c++ layer
+ input.advanceCursor(mg_input.BytesReadInternally);
+
+ m_objectSize = input.getBytesRead() - pos;
+
+ if (m_hashcode == 0)
+ m_hashcode = m_managedptr->GetHashCode();
+
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return this;
+ }
+
+ System::UInt32 ManagedCacheableDeltaGeneric::objectSize() const
+ {
+ try {
+ int ret = m_managedSerializableptr->ObjectSize;
+ if (ret > m_objectSize)
+ return ret;
+ else
+ return m_objectSize;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ System::Int32 ManagedCacheableDeltaGeneric::classId() const
+ {
+ System::UInt32 classId;
+ try {
+ classId = m_managedSerializableptr->ClassId;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return (classId >= 0x80000000 ? 0 : classId);
+ }
+
+ int8_t ManagedCacheableDeltaGeneric::typeId() const
+ {
+ try {
+ System::UInt32 classId = m_classId;
+ if (classId >= 0x80000000) {
+ return (int8_t)((classId - 0x80000000) % 0x20000000);
+ }
+ else if (classId <= 0x7F) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
+ }
+ else if (classId <= 0x7FFF) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
+ }
+ else {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ int8_t ManagedCacheableDeltaGeneric::DSFID() const
+ {
+ // convention that [0x8000000, 0xa0000000) is for FixedIDDefault,
+ // [0xa000000, 0xc0000000) is for FixedIDByte,
+ // [0xc0000000, 0xe0000000) is for FixedIDShort
+ // and [0xe0000000, 0xffffffff] is for FixedIDInt
+ // Note: depends on fact that FixedIDByte is 1, FixedIDShort is 2
+ // and FixedIDInt is 3; if this changes then correct this accordingly
+ System::UInt32 classId = m_managedSerializableptr->ClassId;
+ if (classId >= 0x80000000) {
+ return (int8_t)((classId - 0x80000000) / 0x20000000);
+ }
+ return 0;
+ }
+
+ bool ManagedCacheableDeltaGeneric::hasDelta()
+ {
+ return m_managedptr->HasDelta();
+ }
+
+ void ManagedCacheableDeltaGeneric::toDelta(DataOutput& output) const
+ {
+ try {
+ Apache::Geode::Client::DataOutput mg_output(&output, true);
+ m_managedptr->ToDelta(%mg_output);
+ //this will move the cursor in c++ layer
+ mg_output.WriteBytesToUMDataOutput();
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ void ManagedCacheableDeltaGeneric::fromDelta(DataInput& input)
+ {
+ try {
+ Apache::Geode::Client::DataInput mg_input(&input, true, input.getCache());
+ m_managedptr->FromDelta(%mg_input);
+
+ //this will move the cursor in c++ layer
+ input.advanceCursor(mg_input.BytesReadInternally);
+
+ m_hashcode = m_managedptr->GetHashCode();
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ DeltaPtr ManagedCacheableDeltaGeneric::clone()
+ {
+ try {
+ ICloneable^ cloneable = dynamic_cast<ICloneable^>((
+ Apache::Geode::Client::IGeodeDelta^) m_managedptr);
+ if (cloneable) {
+ Apache::Geode::Client::IGeodeSerializable^ Mclone =
+ dynamic_cast<Apache::Geode::Client::IGeodeSerializable^>(cloneable->Clone());
+ return DeltaPtr(static_cast<ManagedCacheableDeltaGeneric*>(
+ SafeMSerializableConvertGeneric(Mclone)));
+ }
+ else {
+ return Delta::clone();
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return nullptr;
+ }
+
+ bool ManagedCacheableDeltaGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
+ {
+ try {
+ // now checking classId(), typeId(), DSFID() etc. will be much more
+ // expensive than just a dynamic_cast
+ const ManagedCacheableDeltaGeneric* p_other =
+ dynamic_cast<const ManagedCacheableDeltaGeneric*>(&other);
+ if (p_other != NULL) {
+ return m_managedptr->Equals(p_other->ptr());
+ }
+ return false;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ bool ManagedCacheableDeltaGeneric::operator == (const ManagedCacheableDeltaGeneric& other) const
+ {
+ try {
+ return m_managedptr->Equals(other.ptr());
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+
+ }
+
+ System::Int32 ManagedCacheableDeltaGeneric::hashcode() const
+ {
+ throw gcnew System::NotSupportedException;
+ }
+
+ size_t ManagedCacheableDeltaGeneric::logString(char* buffer, size_t maxLength) const
+ {
+ try {
+ if (maxLength > 0) {
+ String^ logstr = m_managedptr->GetType()->Name + '(' +
+ m_managedptr->ToString() + ')';
+ Apache::Geode::Client::ManagedString mg_str(logstr);
+ return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheableDelta.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableDelta.hpp b/clicache/src/impl/ManagedCacheableDelta.hpp
new file mode 100644
index 0000000..9211a8d
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableDelta.hpp
@@ -0,0 +1,189 @@
+/*
+ * 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/Delta.hpp>
+#include "end_native.hpp"
+
+#include "../IGeodeDelta.hpp"
+#include "../IGeodeSerializable.hpp"
+
+
+using namespace System;
+//using namespace apache::geode::client;
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ interface class IGeodeSerializable;
+ interface class IGeodeDelta;
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
+
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.IGeodeDelta" />
+ /// object and implements the native <c>apache::geode::client::CacheableKey</c> interface.
+ /// </summary>
+ class ManagedCacheableDeltaGeneric
+ : public apache::geode::client::CacheableKey, public apache::geode::client::Delta
+ {
+ private:
+ int m_hashcode;
+ int m_classId;
+ int m_objectSize;
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="managedptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedCacheableDeltaGeneric(
+ Apache::Geode::Client::IGeodeDelta^ managedptr)
+ : Delta(nullptr), m_managedptr(managedptr)
+ {
+ m_managedSerializableptr = dynamic_cast <Apache::Geode::Client::IGeodeSerializable^> (managedptr);
+ m_classId = m_managedSerializableptr->ClassId;
+ m_objectSize = 0;
+ }
+
+ inline ManagedCacheableDeltaGeneric(
+ Apache::Geode::Client::IGeodeDelta^ managedptr, int hashcode, int classId)
+ :Delta(nullptr), m_managedptr(managedptr) {
+ m_hashcode = hashcode;
+ m_classId = classId;
+ m_managedSerializableptr = dynamic_cast <Apache::Geode::Client::IGeodeSerializable^> (managedptr);
+ m_objectSize = 0;
+ }
+
+ /// <summary>
+ /// serialize this object
+ /// </summary>
+ virtual void toData(apache::geode::client::DataOutput& output) const;
+
+ /// <summary>
+ /// deserialize this object, typical implementation should return
+ /// the 'this' pointer.
+ /// </summary>
+ virtual apache::geode::client::Serializable* fromData(apache::geode::client::DataInput& input);
+
+ virtual void toDelta(apache::geode::client::DataOutput& output) const;
+
+ virtual void fromDelta(apache::geode::client::DataInput& input);
+
+ /// <summary>
+ /// return the size of this object in bytes
+ /// </summary>
+ virtual System::UInt32 objectSize() const;
+
+ /// <summary>
+ /// return the classId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual System::Int32 classId() const;
+
+ /// <summary>
+ /// return the typeId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual int8_t typeId() const;
+
+ /// <summary>
+ /// return the Data Serialization Fixed ID type.
+ /// This is used to determine what instance type to create
+ /// and deserialize into.
+ ///
+ /// Note that this should not be overridden by custom implementations
+ /// and is reserved only for builtin types.
+ /// </summary>
+ virtual int8_t DSFID() const;
+
+ virtual bool hasDelta();
+
+ virtual apache::geode::client::DeltaPtr clone();
+
+ /// <summary>
+ /// return the hashcode for this key.
+ /// </summary>
+ virtual System::Int32 hashcode() const;
+
+ /// <summary>
+ /// return true if this key matches other CacheableKey
+ /// </summary>
+ virtual bool operator == (const CacheableKey& other) const;
+
+ /// <summary>
+ /// return true if this key matches other ManagedCacheableDeltaGeneric
+ /// </summary>
+ virtual bool operator == (const ManagedCacheableDeltaGeneric& other) const;
+
+ /// <summary>
+ /// Copy the string form of a key into a char* buffer for logging purposes.
+ /// implementations should only generate a string as long as maxLength chars,
+ /// and return the number of chars written. buffer is expected to be large
+ /// enough to hold at least maxLength chars.
+ /// The default implementation renders the classname and instance address.
+ /// </summary>
+ virtual size_t logString(char* buffer, size_t maxLength) const;
+
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::IGeodeDelta^ 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 IGeodeDelta
+ /// 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::IGeodeDelta^> m_managedptr;
+ gcroot<Apache::Geode::Client::IGeodeSerializable^> m_managedSerializableptr;
+ // Disable the copy and assignment constructors
+ ManagedCacheableDeltaGeneric(const ManagedCacheableDeltaGeneric&);
+ ManagedCacheableDeltaGeneric& operator = (const ManagedCacheableDeltaGeneric&);
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableDeltaBytes.cpp b/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
new file mode 100644
index 0000000..18472c4
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
@@ -0,0 +1,337 @@
+/*
+ * 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 "begin_native.hpp"
+#include <GeodeTypeIdsImpl.hpp>
+#include "end_native.hpp"
+
+#include "ManagedCacheableDeltaBytes.hpp"
+#include "../DataInput.hpp"
+#include "../DataOutput.hpp"
+#include "../CacheableString.hpp"
+#include "../ExceptionTypes.hpp"
+#include "SafeConvert.hpp"
+
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ void ManagedCacheableDeltaBytesGeneric::toData(DataOutput& output) const
+ {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::toData: current domain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + System::Convert::ToString((uint64_t) this) + " with its domain ID: " + m_domainId);
+ try {
+ output.writeBytesOnly(m_bytes, m_size);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ Serializable* ManagedCacheableDeltaBytesGeneric::fromData(DataInput& input)
+ {
+ try {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromData: classid " + m_classId);
+ Apache::Geode::Client::DataInput mg_input(&input, true, input.getCache());
+ const System::Byte* objStartPos = input.currentBufferPosition();
+
+ Apache::Geode::Client::IGeodeSerializable^ obj =
+ Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+ obj->FromData(%mg_input);
+ input.advanceCursor(mg_input.BytesReadInternally);
+
+ m_hashCode = obj->GetHashCode();
+
+ const System::Byte* objEndPos = input.currentBufferPosition();
+
+ //m_size = mg_input.BytesRead;
+ m_size = (System::UInt32)(objEndPos - objStartPos);
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromData: objectSize = " + m_size + " m_hashCode = " + m_hashCode);
+ m_bytes = input.getBufferCopyFrom(objStartPos, m_size);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return this;
+ }
+
+ System::UInt32 ManagedCacheableDeltaBytesGeneric::objectSize() const
+ {
+ try {
+ return m_size;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ System::Int32 ManagedCacheableDeltaBytesGeneric::classId() const
+ {
+ System::UInt32 classId;
+ try {
+ classId = m_classId;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return (classId >= 0x80000000 ? 0 : classId);
+ }
+
+ int8_t ManagedCacheableDeltaBytesGeneric::typeId() const
+ {
+ try {
+ System::UInt32 classId = m_classId;
+ if (classId >= 0x80000000) {
+ return (int8_t)((classId - 0x80000000) % 0x20000000);
+ }
+ else if (classId <= 0x7F) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
+ }
+ else if (classId <= 0x7FFF) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
+ }
+ else {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ int8_t ManagedCacheableDeltaBytesGeneric::DSFID() const
+ {
+ // convention that [0x8000000, 0xa0000000) is for FixedIDDefault,
+ // [0xa000000, 0xc0000000) is for FixedIDByte,
+ // [0xc0000000, 0xe0000000) is for FixedIDShort
+ // and [0xe0000000, 0xffffffff] is for FixedIDInt
+ // Note: depends on fact that FixedIDByte is 1, FixedIDShort is 2
+ // and FixedIDInt is 3; if this changes then correct this accordingly
+ System::UInt32 classId = m_classId;
+ if (classId >= 0x80000000) {
+ return (int8_t)((classId - 0x80000000) / 0x20000000);
+ }
+ return 0;
+ }
+
+ bool ManagedCacheableDeltaBytesGeneric::hasDelta()
+ {
+ //Apache::Geode::Client::IGeodeDelta^ deltaObj = this->getManagedObject();
+ //return deltaObj->HasDelta();
+ return m_hasDelta;
+ }
+
+ void ManagedCacheableDeltaBytesGeneric::toDelta(DataOutput& output) const
+ {
+ try {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::toDelta: current domain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + System::Convert::ToString((uint64_t) this) + " with its domain ID: " + m_domainId);
+ Apache::Geode::Client::IGeodeDelta^ deltaObj = this->getManagedObject();
+ Apache::Geode::Client::DataOutput mg_output(&output, true);
+ deltaObj->ToDelta(%mg_output);
+ mg_output.WriteBytesToUMDataOutput();
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ void ManagedCacheableDeltaBytesGeneric::fromDelta(DataInput& input)
+ {
+ try {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromDelta:");
+ Apache::Geode::Client::IGeodeDelta^ deltaObj = this->getManagedObject();
+ Apache::Geode::Client::DataInput mg_input(&input, true, input.getCache());
+ deltaObj->FromDelta(%mg_input);
+
+ Apache::Geode::Client::IGeodeSerializable^ managedptr =
+ dynamic_cast <Apache::Geode::Client::IGeodeSerializable^> (deltaObj);
+ if (managedptr != nullptr)
+ {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromDelta: current domain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + System::Convert::ToString((uint64_t) this) + " with its domain ID: " + m_domainId);
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromDelta: classid " + managedptr->ClassId + " : " + managedptr->ToString());
+ auto dataOut = input.getCache()->createDataOutput();
+ Apache::Geode::Client::DataOutput mg_output(dataOut.get(), true);
+ managedptr->ToData(%mg_output);
+
+ //move cursor
+ //dataOut.advanceCursor(mg_output.BufferLength);
+ mg_output.WriteBytesToUMDataOutput();
+
+ GF_SAFE_DELETE(m_bytes);
+ m_bytes = dataOut->getBufferCopy();
+ m_size = dataOut->getBufferLength();
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::fromDelta objectSize = " + m_size + " m_hashCode = " + m_hashCode);
+ m_hashCode = managedptr->GetHashCode();
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ DeltaPtr ManagedCacheableDeltaBytesGeneric::clone()
+ {
+ try {
+ Apache::Geode::Client::IGeodeDelta^ deltaObj = this->getManagedObject();
+ ICloneable^ cloneable = dynamic_cast<ICloneable^>((Apache::Geode::Client::IGeodeDelta^) deltaObj);
+ if (cloneable) {
+ Apache::Geode::Client::IGeodeSerializable^ Mclone =
+ dynamic_cast<Apache::Geode::Client::IGeodeSerializable^>(cloneable->Clone());
+ return DeltaPtr(static_cast<ManagedCacheableDeltaBytesGeneric*>(
+ SafeMSerializableConvertGeneric(Mclone)));
+ }
+ else {
+ return Delta::clone();
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return nullptr;
+ }
+
+ Apache::Geode::Client::IGeodeDelta^
+ ManagedCacheableDeltaBytesGeneric::getManagedObject() const
+ {
+
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytes::getManagedObject");
+
+ auto dinp = m_cache->createDataInput(m_bytes, m_size);
+ Apache::Geode::Client::DataInput mg_dinp(dinp.get(), true, m_cache);
+ Apache::Geode::Client::TypeFactoryMethodGeneric^ creationMethod =
+ Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId);
+ Apache::Geode::Client::IGeodeSerializable^ newObj = creationMethod();
+
+ Apache::Geode::Client::IGeodeDelta^ managedDeltaptr =
+ dynamic_cast <Apache::Geode::Client::IGeodeDelta^> (newObj->FromData(%mg_dinp));
+ return managedDeltaptr;
+ }
+
+ bool ManagedCacheableDeltaBytesGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
+ {
+ try {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal");
+ // now checking classId(), typeId(), DSFID() etc. will be much more
+ // expensive than just a dynamic_cast
+ const ManagedCacheableDeltaBytesGeneric* p_other =
+ dynamic_cast<const ManagedCacheableDeltaBytesGeneric*>(&other);
+ if (p_other != NULL) {
+ auto di = m_cache->createDataInput(m_bytes, m_size);
+ Apache::Geode::Client::DataInput mg_input(di.get(), true, m_cache);
+ Apache::Geode::Client::IGeodeSerializable^ obj =
+ Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+ obj->FromData(%mg_input);
+ bool ret = obj->Equals(p_other->ptr());
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal return VAL = " + ret);
+ return ret;
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal returns false");
+ return false;
+ }
+
+ bool ManagedCacheableDeltaBytesGeneric::operator ==(const ManagedCacheableDeltaBytesGeneric& other) const
+ {
+ try {
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal. ");
+ auto di = m_cache->createDataInput(m_bytes, m_size);
+ Apache::Geode::Client::DataInput mg_input(di.get(), true, m_cache);
+ Apache::Geode::Client::IGeodeSerializable^ obj =
+ Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
+ obj->FromData(%mg_input);
+ bool ret = obj->Equals(other.ptr());
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal return VAL = " + ret);
+ return ret;
+ //return obj->Equals(other.get());
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal return false");
+ return false;
+ }
+
+ System::Int32 ManagedCacheableDeltaBytesGeneric::hashcode() const
+ {
+ throw gcnew System::NotSupportedException;
+ }
+
+ size_t ManagedCacheableDeltaBytesGeneric::logString(char* buffer, size_t maxLength) const
+ {
+ try {
+ Apache::Geode::Client::IGeodeDelta^ manageObject = getManagedObject();
+ if (manageObject != nullptr)
+ {
+ if (maxLength > 0) {
+ String^ logstr = manageObject->GetType()->Name + '(' +
+ manageObject->ToString() + ')';
+ Apache::Geode::Client::ManagedString mg_str(logstr);
+ return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
+ }
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheableDeltaBytes.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableDeltaBytes.hpp b/clicache/src/impl/ManagedCacheableDeltaBytes.hpp
new file mode 100644
index 0000000..c5fcbb2
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableDeltaBytes.hpp
@@ -0,0 +1,218 @@
+/*
+ * 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 "SerializationRegistry.hpp"
+#include <geode/Cache.hpp>
+#include <geode/Delta.hpp>
+#include <geode/DataOutput.hpp>
+#include "end_native.hpp"
+
+#include "../Log.hpp"
+#include "../DataOutput.hpp"
+
+using namespace System;
+
+namespace Apache
+{
+ namespace Geode
+ {
+ namespace Client
+ {
+
+ interface class IGeodeSerializable;
+ interface class IGeodeDelta;
+ } // namespace Client
+ } // namespace Geode
+} // namespace Apache
+
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.IGeodeDelta" />
+ /// object and implements the native <c>apache::geode::client::CacheableKey</c> interface.
+ /// </summary>
+ class ManagedCacheableDeltaBytesGeneric
+ : public CacheableKey, public Delta
+ {
+ public:
+
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="managedDeltaptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedCacheableDeltaBytesGeneric(
+ Apache::Geode::Client::IGeodeDelta^ managedDeltaptr, bool storeBytes)
+ :Delta(nullptr), m_domainId(System::Threading::Thread::GetDomainID()),
+ m_classId(0),
+ m_bytes(NULL),
+ m_size(0),
+ m_hasDelta(false),
+ m_hashCode(0)
+ {
+ if (storeBytes)
+ m_hasDelta = managedDeltaptr->HasDelta();
+ Apache::Geode::Client::IGeodeSerializable^ managedptr =
+ dynamic_cast <Apache::Geode::Client::IGeodeSerializable^> (managedDeltaptr);
+ if (managedptr != nullptr)
+ {
+ m_classId = managedptr->ClassId;
+ Apache::Geode::Client::Log::Finer("ManagedCacheableDeltaBytes::Constructor: current AppDomain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + System::Convert::ToString((uint64_t) this) + " with its AppDomain ID: " + m_domainId);
+ Apache::Geode::Client::Log::Finer("ManagedCacheableDeltaBytes::Constructor: class ID " + managedptr->ClassId + " : " + managedptr->ToString() + " storeBytes:" + storeBytes);
+ if (storeBytes)
+ {
+ auto dataOut = m_cache->createDataOutput();
+ Apache::Geode::Client::DataOutput mg_output(dataOut.get(), true);
+ managedptr->ToData(%mg_output);
+
+ //move cursor
+ //dataOut.advanceCursor(mg_output.BufferLength);
+ mg_output.WriteBytesToUMDataOutput();
+
+ m_bytes = dataOut->getBufferCopy();
+ m_size = dataOut->getBufferLength();
+ m_hashCode = managedptr->GetHashCode();
+ Apache::Geode::Client::Log::Finer("ManagedCacheableDeltaBytes::Constructor objectSize = " + m_size + " m_hashCode = " + m_hashCode);
+ }
+ }
+ }
+
+ /// <summary>
+ /// serialize this object
+ /// </summary>
+ virtual void toData(apache::geode::client::DataOutput& output) const;
+
+ /// <summary>
+ /// deserialize this object, typical implementation should return
+ /// the 'this' pointer.
+ /// </summary>
+ virtual apache::geode::client::Serializable* fromData(apache::geode::client::DataInput& input);
+
+ virtual void toDelta(apache::geode::client::DataOutput& output) const;
+
+ virtual void fromDelta(apache::geode::client::DataInput& input);
+
+ /// <summary>
+ /// return the size of this object in bytes
+ /// </summary>
+ virtual System::UInt32 objectSize() const;
+
+ /// <summary>
+ /// return the classId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual System::Int32 classId() const;
+
+ /// <summary>
+ /// return the typeId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual int8_t typeId() const;
+
+ /// <summary>
+ /// return the Data Serialization Fixed ID type.
+ /// This is used to determine what instance type to create
+ /// and deserialize into.
+ ///
+ /// Note that this should not be overridden by custom implementations
+ /// and is reserved only for builtin types.
+ /// </summary>
+ virtual int8_t DSFID() const;
+
+ virtual bool hasDelta();
+
+ virtual apache::geode::client::DeltaPtr clone();
+
+ /// <summary>
+ /// return the hashcode for this key.
+ /// </summary>
+ virtual System::Int32 hashcode() const;
+
+ /// <summary>
+ /// return true if this key matches other CacheableKey
+ /// </summary>
+ virtual bool operator == (const CacheableKey& other) const;
+
+ /// <summary>
+ /// return true if this key matches other ManagedCacheableDeltaBytesGeneric
+ /// </summary>
+ virtual bool operator == (const ManagedCacheableDeltaBytesGeneric& other) const;
+
+ /// <summary>
+ /// Copy the string form of a key into a char* buffer for logging purposes.
+ /// implementations should only generate a string as long as maxLength chars,
+ /// and return the number of chars written. buffer is expected to be large
+ /// enough to hold at least maxLength chars.
+ /// The default implementation renders the classname and instance address.
+ /// </summary>
+ virtual size_t logString(char* buffer, size_t maxLength) const;
+
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::IGeodeDelta^ ptr() const
+ {
+ return getManagedObject();
+ }
+
+ inline ~ManagedCacheableDeltaBytesGeneric()
+ {
+ Apache::Geode::Client::Log::Finer("ManagedCacheableDeltaBytes::Destructor current AppDomain ID: " + System::Threading::Thread::GetDomainID() + " for object: " + System::Convert::ToString((uint64_t) this) + " with its AppDomain ID: " + m_domainId);
+ GF_SAFE_DELETE(m_bytes);
+ }
+
+ private:
+ Apache::Geode::Client::IGeodeDelta^ getManagedObject() const;
+ /// <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 IGeodeDelta
+ /// 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::IGeodeDelta^> m_managedptr;
+ //gcroot<Apache::Geode::Client::IGeodeSerializable^> m_managedSerializableptr;
+
+ int m_domainId;
+ UInt32 m_classId;
+ System::Byte * m_bytes;
+ System::UInt32 m_size;
+ System::UInt32 m_hashCode;
+ bool m_hasDelta;
+
+ // Disable the copy and assignment constructors
+ ManagedCacheableDeltaBytesGeneric(const ManagedCacheableDeltaBytesGeneric&);
+ ManagedCacheableDeltaBytesGeneric& operator = (const ManagedCacheableDeltaBytesGeneric&);
+ };
+
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableKey.cpp b/clicache/src/impl/ManagedCacheableKey.cpp
new file mode 100644
index 0000000..8cefef9
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableKey.cpp
@@ -0,0 +1,230 @@
+/*
+ * 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 "begin_native.hpp"
+#include <GeodeTypeIdsImpl.hpp>
+#include "end_native.hpp"
+
+#include "../ICacheableKey.hpp"
+#include "ManagedCacheableKey.hpp"
+#include "../DataInput.hpp"
+#include "../DataOutput.hpp"
+#include "../CacheableString.hpp"
+#include "../ExceptionTypes.hpp"
+#include "../Log.hpp"
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+
+ void ManagedCacheableKeyGeneric::toData(apache::geode::client::DataOutput& output) const
+ {
+ try {
+ System::UInt32 pos = (int)output.getBufferLength();
+ //Apache::Geode::Client::Log::Debug("ManagedCacheableKeyGeneric::toData");
+ Apache::Geode::Client::DataOutput mg_output(&output, true);
+ m_managedptr->ToData(%mg_output);
+ //this will move the cursor in c++ layer
+ mg_output.WriteBytesToUMDataOutput();
+
+ ManagedCacheableKeyGeneric* tmp = const_cast<ManagedCacheableKeyGeneric*>(this);
+ tmp->m_objectSize = (int)(output.getBufferLength() - pos);
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ }
+
+ apache::geode::client::Serializable* ManagedCacheableKeyGeneric::fromData(apache::geode::client::DataInput& input)
+ {
+ try {
+ int pos = input.getBytesRead();
+ //Apache::Geode::Client::Log::Debug("ManagedCacheableKeyGeneric::fromData");
+ Apache::Geode::Client::DataInput mg_input(&input, true, input.getCache());
+ m_managedptr = m_managedptr->FromData(%mg_input);
+
+ //this will move the cursor in c++ layer
+ input.advanceCursor(mg_input.BytesReadInternally);
+ m_objectSize = input.getBytesRead() - pos;
+ //if(m_hashcode == 0)
+ //m_hashcode = m_managedptr->GetHashCode();
+
+
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return this;
+ }
+
+ System::UInt32 ManagedCacheableKeyGeneric::objectSize() const
+ {
+ try {
+ int ret = m_managedptr->ObjectSize;
+ if (ret > m_objectSize)
+ return ret;
+ else
+ return m_objectSize;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ System::Int32 ManagedCacheableKeyGeneric::classId() const
+ {
+ return (m_classId >= 0x80000000 ? 0 : m_classId);
+ }
+
+ int8_t ManagedCacheableKeyGeneric::typeId() const
+ {
+ if (m_classId >= 0x80000000) {
+ return (int8_t)((m_classId - 0x80000000) % 0x20000000);
+ }
+ else if (m_classId <= 0x7F) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData;
+ }
+ else if (m_classId <= 0x7FFF) {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData2;
+ }
+ else {
+ return (int8_t)GeodeTypeIdsImpl::CacheableUserData4;
+ }
+ }
+
+ int8_t ManagedCacheableKeyGeneric::DSFID() const
+ {
+ if (m_classId >= 0x80000000) {
+ return (int8_t)((m_classId - 0x80000000) / 0x20000000);
+ }
+ return 0;
+ }
+
+ apache::geode::client::CacheableStringPtr ManagedCacheableKeyGeneric::toString() const
+ {
+ try {
+ apache::geode::client::CacheableStringPtr cStr;
+ Apache::Geode::Client::CacheableString::GetCacheableString(
+ m_managedptr->ToString(), cStr);
+ return cStr;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return nullptr;
+ }
+
+ bool ManagedCacheableKeyGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
+ {
+ try {
+ // now checking classId(), typeId(), DSFID() etc. will be much more
+ // expensive than just a dynamic_cast
+ const ManagedCacheableKeyGeneric* p_other =
+ dynamic_cast<const ManagedCacheableKeyGeneric*>(&other);
+ if (p_other != NULL) {
+ return static_cast<Apache::Geode::Client::ICacheableKey^>(
+ (static_cast<Apache::Geode::Client::IGeodeSerializable^>((Apache::Geode::Client::IGeodeSerializable^)m_managedptr)))->Equals(
+ static_cast<Apache::Geode::Client::ICacheableKey^>(p_other->ptr()));
+ }
+ return false;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ bool ManagedCacheableKeyGeneric::operator ==(const ManagedCacheableKeyGeneric& other) const
+ {
+ try {
+ return static_cast<Apache::Geode::Client::ICacheableKey^>(
+ (Apache::Geode::Client::IGeodeSerializable^)(Apache::Geode::Client::IGeodeSerializable^)m_managedptr)->Equals(
+ static_cast<Apache::Geode::Client::ICacheableKey^>(other.ptr()));
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return false;
+ }
+
+ System::Int32 ManagedCacheableKeyGeneric::hashcode() const
+ {
+ if (m_hashcode != 0)
+ return m_hashcode;
+ try {
+
+ ManagedCacheableKeyGeneric* tmp = const_cast<ManagedCacheableKeyGeneric*>(this);
+ tmp->m_hashcode = ((Apache::Geode::Client::ICacheableKey^)
+ (Apache::Geode::Client::IGeodeSerializable^)m_managedptr)
+ ->GetHashCode();
+ return m_hashcode;
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ size_t ManagedCacheableKeyGeneric::logString(char* buffer, size_t maxLength) const
+ {
+ try {
+ if (maxLength > 0) {
+ String^ logstr = m_managedptr->GetType()->Name + '(' +
+ m_managedptr->ToString() + ')';
+ Apache::Geode::Client::ManagedString mg_str(logstr);
+ return snprintf(buffer, maxLength, "%s", mg_str.CharPtr);
+ }
+ }
+ catch (Apache::Geode::Client::GeodeException^ ex) {
+ ex->ThrowNative();
+ }
+ catch (System::Exception^ ex) {
+ Apache::Geode::Client::GeodeException::ThrowNative(ex);
+ }
+ return 0;
+ }
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/src/impl/ManagedCacheableKey.hpp
----------------------------------------------------------------------
diff --git a/clicache/src/impl/ManagedCacheableKey.hpp b/clicache/src/impl/ManagedCacheableKey.hpp
new file mode 100644
index 0000000..1f3c27f
--- /dev/null
+++ b/clicache/src/impl/ManagedCacheableKey.hpp
@@ -0,0 +1,173 @@
+/*
+ * 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/CacheableKey.hpp>
+#include <GeodeTypeIdsImpl.hpp>
+#include "SerializationRegistry.hpp"
+#include "end_native.hpp"
+
+#include "../IGeodeSerializable.hpp"
+
+using namespace System;
+
+namespace apache
+{
+ namespace geode
+ {
+ namespace client
+ {
+ namespace native = apache::geode::client;
+
+ /// <summary>
+ /// Wraps the managed <see cref="Apache.Geode.Client.IGeodeSerializable" />
+ /// object and implements the native <c>apache::geode::client::CacheableKey</c> interface.
+ /// </summary>
+ class ManagedCacheableKeyGeneric
+ : public apache::geode::client::CacheableKey
+ {
+ private:
+ int m_hashcode;
+ int m_classId;
+ native::SerializationRegistry* m_serializationRegistry;
+ int m_objectSize;
+ public:
+
+ inline ManagedCacheableKeyGeneric(
+ Apache::Geode::Client::IGeodeSerializable^ managedptr, int hashcode, int classId, native::SerializationRegistry * serializationRegistry)
+ : m_managedptr(managedptr) {
+ m_hashcode = hashcode;
+ m_classId = classId;
+ m_serializationRegistry = serializationRegistry;
+ m_objectSize = 0;
+ }
+ /// <summary>
+ /// Constructor to initialize with the provided managed object.
+ /// </summary>
+ /// <param name="managedptr">
+ /// The managed object.
+ /// </param>
+ inline ManagedCacheableKeyGeneric(Apache::Geode::Client::IGeodeSerializable^ managedptr, native::SerializationRegistry * serializationRegistry)
+ : m_managedptr(managedptr) {
+ // m_hashcode = managedptr->GetHashCode();
+ m_hashcode = 0;
+ m_classId = managedptr->ClassId;
+ m_serializationRegistry = serializationRegistry;
+ m_objectSize = 0;
+ }
+
+ /// <summary>
+ /// serialize this object
+ /// </summary>
+ virtual void toData(apache::geode::client::DataOutput& output) const;
+
+ /// <summary>
+ /// deserialize this object, typical implementation should return
+ /// the 'this' pointer.
+ /// </summary>
+ virtual apache::geode::client::Serializable* fromData(apache::geode::client::DataInput& input);
+
+
+ /// <summary>
+ /// return the size of this object in bytes
+ /// </summary>
+ virtual System::UInt32 objectSize() const;
+
+ /// <summary>
+ /// return the classId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual System::Int32 classId() const;
+
+ /// <summary>
+ /// return the typeId of the instance being serialized.
+ /// This is used by deserialization to determine what instance
+ /// type to create and deserialize into.
+ /// </summary>
+ virtual int8_t typeId() const;
+
+ /// <summary>
+ /// return the Data Serialization Fixed ID type.
+ /// This is used to determine what instance type to create
+ /// and deserialize into.
+ ///
+ /// Note that this should not be overridden by custom implementations
+ /// and is reserved only for builtin types.
+ /// </summary>
+ virtual int8_t DSFID() const;
+
+ /// <summary>
+ /// Display this object as 'string', which depends on the implementation in
+ /// the managed class
+ /// </summary>
+ virtual apache::geode::client::CacheableStringPtr toString() const;
+
+ /// <summary>
+ /// return true if this key matches other CacheableKey
+ /// </summary>
+ virtual bool operator == (const CacheableKey& other) const;
+ /// <summary>
+ /// return true if this key matches other ManagedCacheableKey
+ /// </summary>
+ virtual bool operator == (const ManagedCacheableKeyGeneric& other) const;
+
+ /// <summary>
+ /// return the hashcode for this key.
+ /// </summary>
+ virtual System::Int32 hashcode() const;
+
+ /// <summary>
+ /// Copy the string form of a key into a char* buffer for logging purposes.
+ /// implementations should only generate a string as long as maxLength chars,
+ /// and return the number of chars written. buffer is expected to be large
+ /// enough to hold at least maxLength chars.
+ /// The default implementation renders the classname and instance address.
+ /// </summary>
+ virtual size_t logString(char* buffer, size_t maxLength) const;
+
+ /// <summary>
+ /// Returns the wrapped managed object reference.
+ /// </summary>
+ inline Apache::Geode::Client::IGeodeSerializable^ 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 IGeodeSerializable
+ /// 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::IGeodeSerializable^> m_managedptr;
+
+ // Disable the copy and assignment constructors
+ ManagedCacheableKeyGeneric(const ManagedCacheableKeyGeneric&);
+ ManagedCacheableKeyGeneric& operator = (const ManagedCacheableKeyGeneric&);
+ };
+
+ } // namespace client
+ } // namespace geode
+} // namespace apache