| /* |
| * 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 <geode/Cache.hpp> |
| #include <geode/PoolManager.hpp> |
| #include "SerializationRegistry.hpp" |
| #include "CacheRegionHelper.hpp" |
| #include "end_native.hpp" |
| |
| #include <msclr/lock.h> |
| |
| #include "Serializable.hpp" |
| #include "impl/DelegateWrapper.hpp" |
| #include "DataOutput.hpp" |
| #include "DataInput.hpp" |
| #include "CacheableStringArray.hpp" |
| #include "CacheableBuiltins.hpp" |
| #include "impl/SafeConvert.hpp" |
| #include "CacheableHashTable.hpp" |
| #include "Struct.hpp" |
| #include "CacheableUndefined.hpp" |
| #include "CacheableObject.hpp" |
| #include "CacheableStack.hpp" |
| #include "CacheableObjectXml.hpp" |
| #include "CacheableHashSet.hpp" |
| #include "CacheableObjectArray.hpp" |
| #include "CacheableLinkedList.hpp" |
| #include "CacheableFileName.hpp" |
| #include "CacheableIdentityHashMap.hpp" |
| #include "IPdxSerializer.hpp" |
| #include "impl/DotNetTypes.hpp" |
| #include "CacheRegionHelper.hpp" |
| #include "Cache.hpp" |
| |
| #pragma warning(disable:4091) |
| |
| using namespace System::Reflection; |
| using namespace System::Reflection::Emit; |
| |
| using namespace System; |
| using namespace System::Collections::Generic; |
| using namespace Runtime::InteropServices; |
| using namespace apache::geode::client; |
| |
| namespace Apache |
| { |
| namespace Geode |
| { |
| namespace Client |
| { |
| using namespace msclr::interop; |
| namespace native = apache::geode::client; |
| |
| System::UInt64 Apache::Geode::Client::Serializable::ObjectSize::get() |
| { |
| try |
| { |
| return m_nativeptr->get()->objectSize(); |
| } |
| finally |
| { |
| GC::KeepAlive(m_nativeptr); |
| } |
| } |
| |
| String^ Apache::Geode::Client::Serializable::ToString() |
| { |
| try |
| { |
| return marshal_as<String^>(m_nativeptr->get()->toString()); |
| } |
| finally |
| { |
| GC::KeepAlive(m_nativeptr); |
| } |
| } |
| |
| System::Int32 Serializable::GetPDXIdForType(native::Pool* pool, ISerializable^ pdxType, Cache^ cache) |
| { |
| std::shared_ptr<native::Cacheable> kPtr(GetNativeWrapperForManagedObject(pdxType)); |
| return CacheRegionHelper::getCacheImpl(cache->GetNative().get()) |
| ->getSerializationRegistry() |
| ->GetPDXIdForType(pool, kPtr); |
| } |
| |
| ISerializable^ Serializable::GetPDXTypeById(native::Pool* pool, System::Int32 typeId, Cache^ cache) |
| { |
| auto sPtr = CacheRegionHelper::getCacheImpl(cache->GetNative().get()) |
| ->getSerializationRegistry() |
| ->GetPDXTypeById(pool, typeId); |
| return SafeUMSerializableConvertGeneric(sPtr); |
| } |
| |
| int Serializable::GetEnumValue(Internal::EnumInfo^ ei, Cache^ cache) |
| { |
| std::shared_ptr<native::Cacheable> kPtr(GetNativeWrapperForManagedObject(ei)); |
| auto&& cacheImpl = CacheRegionHelper::getCacheImpl(cache->GetNative().get()); |
| return cacheImpl->getSerializationRegistry()->GetEnumValue(cacheImpl->getDefaultPool(), kPtr); |
| } |
| |
| Internal::EnumInfo^ Serializable::GetEnum(int val, Cache^ cache) |
| { |
| auto cacheImpl = CacheRegionHelper::getCacheImpl(cache->GetNative().get()); |
| auto sPtr = cacheImpl->getSerializationRegistry()->GetEnum(cacheImpl->getDefaultPool(), val); |
| return (Internal::EnumInfo^)SafeUMSerializableConvertGeneric(sPtr); |
| } |
| |
| generic<class TKey> |
| std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(TKey key) |
| { |
| if (key != nullptr) { |
| return GetUnmanagedValueGeneric(key->GetType(), key); |
| } |
| return nullptr; |
| } |
| |
| generic<class TKey> |
| std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric(TKey key, bool isAciiChar) |
| { |
| if (key != nullptr) { |
| return GetUnmanagedValueGeneric(key->GetType(), key, isAciiChar); |
| } |
| return nullptr; |
| } |
| |
| generic<class TKey> |
| std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric( |
| Type^ managedType, TKey key) |
| { |
| return GetUnmanagedValueGeneric(managedType, key, false); |
| } |
| |
| generic<class TKey> |
| std::shared_ptr<native::CacheableKey> Serializable::GetUnmanagedValueGeneric( |
| Type^ managedType, TKey key, bool isAsciiChar) |
| { |
| Byte typeId = Apache::Geode::Client::TypeRegistry::GetDsCodeForManagedType(managedType); |
| |
| switch (typeId) |
| { |
| case native::internal::DSCode::CacheableByte: { |
| return Serializable::getCacheableByte((Byte)key); |
| } |
| case native::internal::DSCode::CacheableBoolean: |
| return Serializable::getCacheableBoolean((bool)key); |
| case native::internal::DSCode::CacheableCharacter: |
| return Serializable::getCacheableWideChar((Char)key); |
| case native::internal::DSCode::CacheableDouble: |
| return Serializable::getCacheableDouble((double)key); |
| case native::internal::DSCode::CacheableASCIIString: |
| return Serializable::GetCacheableString((String^)key); |
| case native::internal::DSCode::CacheableFloat: |
| return Serializable::getCacheableFloat((float)key); |
| case native::internal::DSCode::CacheableInt16: { |
| return Serializable::getCacheableInt16((System::Int16)key); |
| } |
| case native::internal::DSCode::CacheableInt32: { |
| return Serializable::getCacheableInt32((System::Int32)key); |
| } |
| case native::internal::DSCode::CacheableInt64: { |
| return Serializable::getCacheableInt64((System::Int64)key); |
| } |
| case native::internal::DSCode::CacheableBytes: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableBytes::Create((array<Byte>^)key)); |
| } |
| case native::internal::DSCode::CacheableDoubleArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableDoubleArray::Create((array<Double>^)key)); |
| } |
| case native::internal::DSCode::CacheableFloatArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableFloatArray::Create((array<float>^)key)); |
| } |
| case native::internal::DSCode::CacheableInt16Array: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt16Array::Create((array<Int16>^)key)); |
| } |
| case native::internal::DSCode::CacheableInt32Array: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt32Array::Create((array<Int32>^)key)); |
| } |
| case native::internal::DSCode::CacheableInt64Array: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableInt64Array::Create((array<Int64>^)key)); |
| } |
| case native::internal::DSCode::CacheableStringArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableStringArray::Create((array<String^>^)key)); |
| } |
| case native::internal::DSCode::CacheableFileName: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableFileName^)key); |
| } |
| case native::internal::DSCode::CacheableHashTable://collection::hashtable |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableHashTable::Create((System::Collections::Hashtable^)key)); |
| } |
| case native::internal::DSCode::CacheableHashMap://generic dictionary |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableHashMap::Create((System::Collections::IDictionary^)key)); |
| } |
| case native::internal::DSCode::CacheableVector://collection::arraylist |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(CacheableVector::Create((System::Collections::IList^)key)); |
| } |
| case native::internal::DSCode::CacheableArrayList://generic ilist |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableArrayList::Create((System::Collections::IList^)key)); |
| } |
| case native::internal::DSCode::CacheableLinkedList://generic linked list |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableLinkedList::Create((System::Collections::Generic::LinkedList<Object^>^)key)); |
| } |
| case native::internal::DSCode::CacheableStack: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableStack::Create((System::Collections::ICollection^)key)); |
| } |
| case native::internal::InternalId::CacheableManagedObject: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObject^)key); |
| } |
| case native::internal::InternalId::CacheableManagedObjectXml: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObjectXml^)key); |
| } |
| case native::internal::DSCode::CacheableObjectArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableObjectArray^)key); |
| } |
| case native::internal::DSCode::CacheableIdentityHashMap: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableIdentityHashMap::Create((System::Collections::IDictionary^)key)); |
| } |
| case native::internal::DSCode::CacheableHashSet://no need of it, default case should work |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableHashSet^)key); |
| } |
| case native::internal::DSCode::CacheableLinkedHashSet://no need of it, default case should work |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable((Apache::Geode::Client::CacheableLinkedHashSet^)key); |
| } |
| case native::internal::DSCode::CacheableDate: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CacheableDate::Create((System::DateTime)key)); |
| } |
| case native::internal::DSCode::BooleanArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::BooleanArray::Create((array<bool>^)key)); |
| } |
| case native::internal::DSCode::CharArray: |
| { |
| return GetNativeCacheableKeyWrapperForManagedISerializable(Apache::Geode::Client::CharArray::Create((array<Char>^)key)); |
| } |
| default: |
| { |
| std::shared_ptr<native::Cacheable> kPtr(GetNativeWrapperForManagedObject(key)); |
| return std::dynamic_pointer_cast<native::CacheableKey>(kPtr); |
| } |
| } |
| } // |
| |
| std::shared_ptr<native::CacheableKey> Serializable::GetNativeCacheableKeyWrapperForManagedISerializable(ISerializable^ managedObject) { |
| if (nullptr == managedObject) { |
| return __nullptr; |
| } |
| auto wrappedObject = std::shared_ptr<native::Serializable>(GetNativeWrapperForManagedObject(managedObject)); |
| return std::dynamic_pointer_cast<native::CacheableKey>(wrappedObject); |
| } |
| |
| // These are the new static methods to get/put data from c++ |
| |
| //byte |
| Byte Serializable::getByte(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableByte*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableByte(Byte val) |
| { |
| return native::CacheableByte::create(val); |
| } |
| |
| //boolean |
| bool Serializable::getBoolean(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableBoolean*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableBoolean(bool val) |
| { |
| return native::CacheableBoolean::create(val); |
| } |
| |
| //widechar |
| Char Serializable::getChar(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableCharacter*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableWideChar(Char val) |
| { |
| return native::CacheableCharacter::create(val); |
| } |
| |
| //double |
| double Serializable::getDouble(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableDouble*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableDouble(double val) |
| { |
| return native::CacheableDouble::create(val); |
| } |
| |
| //float |
| float Serializable::getFloat(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableFloat*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableFloat(float val) |
| { |
| return native::CacheableFloat::create(val); |
| } |
| |
| //int16 |
| System::Int16 Serializable::getInt16(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableInt16*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt16(int val) |
| { |
| return native::CacheableInt16::create(val); |
| } |
| |
| //int32 |
| System::Int32 Serializable::getInt32(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableInt32*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt32(System::Int32 val) |
| { |
| return native::CacheableInt32::create(val); |
| } |
| |
| //int64 |
| System::Int64 Serializable::getInt64(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| auto ci = dynamic_cast<native::CacheableInt64*>(nativeptr.get()); |
| return ci->value(); |
| } |
| |
| std::shared_ptr<native::CacheableKey> Serializable::getCacheableInt64(System::Int64 val) |
| { |
| return native::CacheableInt64::create(val); |
| } |
| |
| //cacheable ascii string |
| String^ Serializable::getString(std::shared_ptr<native::Serializable> nativeptr) |
| { |
| if (auto cacheableString = std::dynamic_pointer_cast<native::CacheableString>(nativeptr)) |
| { |
| return marshal_as<String^>(cacheableString->value()); |
| } |
| |
| return marshal_as<String^>(nativeptr->toString()); |
| } |
| |
| std::shared_ptr<native::CacheableString> Serializable::GetCacheableString(String^ value) |
| { |
| std::shared_ptr<native::CacheableString> cStr; |
| if (value) { |
| cStr = native::CacheableString::create(marshal_as<std::string>(value)); |
| } |
| else { |
| cStr = std::dynamic_pointer_cast<native::CacheableString>(native::CacheableString::createDeserializable()); |
| } |
| |
| return cStr; |
| } |
| |
| array<Byte>^ Serializable::getSByteArray(array<SByte>^ sArray) |
| { |
| array<Byte>^ dArray = gcnew array<Byte>(sArray->Length); |
| for (int index = 0; index < dArray->Length; index++) |
| { |
| dArray[index] = sArray[index]; |
| } |
| return dArray; |
| } |
| |
| array<System::Int16>^ Serializable::getInt16Array(array<System::UInt16>^ sArray) |
| { |
| array<System::Int16>^ dArray = gcnew array<System::Int16>(sArray->Length); |
| for (int index = 0; index < dArray->Length; index++) |
| { |
| dArray[index] = sArray[index]; |
| } |
| return dArray; |
| } |
| |
| array<System::Int32>^ Serializable::getInt32Array(array<System::UInt32>^ sArray) |
| { |
| array<System::Int32>^ dArray = gcnew array<System::Int32>(sArray->Length); |
| for (int index = 0; index < dArray->Length; index++) |
| { |
| dArray[index] = sArray[index]; |
| } |
| return dArray; |
| } |
| |
| array<System::Int64>^ Serializable::getInt64Array(array<System::UInt64>^ sArray) |
| { |
| array<System::Int64>^ dArray = gcnew array<System::Int64>(sArray->Length); |
| for (int index = 0; index < dArray->Length; index++) |
| { |
| dArray[index] = sArray[index]; |
| } |
| return dArray; |
| } |
| } // namespace Client |
| } // namespace Geode |
| } // namespace Apache |
