| /* |
| * 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 |
| |
| #ifndef GEODE_INTEGRATION_TEST_THINCLIENTPDXSERIALIZERS_H_ |
| #define GEODE_INTEGRATION_TEST_THINCLIENTPDXSERIALIZERS_H_ |
| |
| namespace { // NOLINT(google-build-namespaces) |
| |
| using apache::geode::client::CacheableArrayList; |
| using apache::geode::client::CacheableHashMap; |
| using apache::geode::client::CacheableHashSet; |
| using apache::geode::client::CacheableHashTable; |
| using apache::geode::client::CacheableLinkedHashSet; |
| using apache::geode::client::CacheableVector; |
| using apache::geode::client::PdxReader; |
| using apache::geode::client::PdxSerializer; |
| using apache::geode::client::PdxWriter; |
| using apache::geode::client::UserObjectSizer; |
| |
| using PdxTests::TestPdxSerializerForV2; |
| using PdxTests::V1CLASSNAME2; |
| using PdxTests::V2CLASSNAME4; |
| |
| static const char* CLASSNAME1 = "PdxTests.PdxType"; |
| static const char* CLASSNAME2 = "PdxTests.Address"; |
| |
| class TestPdxSerializer : public PdxSerializer { |
| public: |
| static void deallocate(void* testObject, const std::string& className) { |
| ASSERT(className == CLASSNAME1 || className == CLASSNAME2, |
| "Unexpected classname in deallocate()"); |
| LOG("TestPdxSerializer::deallocate called"); |
| if (className == CLASSNAME1) { |
| PdxTests::NonPdxType* nonPdxType = |
| reinterpret_cast<PdxTests::NonPdxType*>(testObject); |
| delete nonPdxType; |
| } else { |
| PdxTests::NonPdxAddress* nonPdxAddress = |
| reinterpret_cast<PdxTests::NonPdxAddress*>(testObject); |
| delete nonPdxAddress; |
| } |
| } |
| |
| static size_t objectSize(const std::shared_ptr<const void>&, |
| const std::string& className) { |
| ASSERT(className == CLASSNAME1 || className == CLASSNAME2, |
| "Unexpected classname in objectSize()"); |
| LOG("TestPdxSerializer::objectSize called"); |
| return 12345; // dummy value |
| } |
| |
| UserObjectSizer getObjectSizer(const std::string& className) override { |
| ASSERT(className == CLASSNAME1 || className == CLASSNAME2, |
| "Unexpected classname in getObjectSizer"); |
| return objectSize; |
| } |
| |
| std::shared_ptr<void> fromDataForAddress(PdxReader& pr) { |
| try { |
| auto nonPdxAddress = std::make_shared<PdxTests::NonPdxAddress>(); |
| nonPdxAddress->_aptNumber = pr.readInt("_aptNumber"); |
| nonPdxAddress->_street = pr.readString("_street"); |
| nonPdxAddress->_city = pr.readString("_city"); |
| return std::move(nonPdxAddress); |
| } catch (...) { |
| return nullptr; |
| } |
| } |
| |
| std::shared_ptr<void> fromData(const std::string& className, |
| PdxReader& pdxReader) override { |
| ASSERT(className == CLASSNAME1 || className == CLASSNAME2, |
| "Unexpected classname in fromData"); |
| |
| if (className == CLASSNAME2) { |
| return fromDataForAddress(pdxReader); |
| } |
| |
| auto nonPdxType = std::make_shared<PdxTests::NonPdxType>(); |
| |
| try { |
| auto Lengtharr = new int32_t[2]; |
| int32_t arrLen = 0; |
| nonPdxType->m_byteByteArray = pdxReader.readArrayOfByteArrays( |
| "m_byteByteArray", arrLen, &Lengtharr); |
| // TODO::need to write compareByteByteArray() and check for |
| // m_byteByteArray elements |
| |
| nonPdxType->m_char = pdxReader.readChar("m_char"); |
| // GenericValCompare |
| |
| nonPdxType->m_bool = pdxReader.readBoolean("m_bool"); |
| // GenericValCompare |
| nonPdxType->m_boolArray = pdxReader.readBooleanArray("m_boolArray"); |
| |
| nonPdxType->m_byte = pdxReader.readByte("m_byte"); |
| nonPdxType->m_byteArray = pdxReader.readByteArray("m_byteArray"); |
| nonPdxType->m_charArray = pdxReader.readCharArray("m_charArray"); |
| |
| nonPdxType->m_arraylist = std::dynamic_pointer_cast<CacheableArrayList>( |
| pdxReader.readObject("m_arraylist")); |
| |
| nonPdxType->m_map = std::dynamic_pointer_cast<CacheableHashMap>( |
| pdxReader.readObject("m_map")); |
| // TODO:Check for the size |
| |
| nonPdxType->m_hashtable = std::dynamic_pointer_cast<CacheableHashTable>( |
| pdxReader.readObject("m_hashtable")); |
| // TODO:Check for the size |
| |
| nonPdxType->m_vector = std::dynamic_pointer_cast<CacheableVector>( |
| pdxReader.readObject("m_vector")); |
| // TODO::Check for size |
| |
| nonPdxType->m_chs = std::dynamic_pointer_cast<CacheableHashSet>( |
| pdxReader.readObject("m_chs")); |
| // TODO::Size check |
| |
| nonPdxType->m_clhs = std::dynamic_pointer_cast<CacheableLinkedHashSet>( |
| pdxReader.readObject("m_clhs")); |
| // TODO:Size check |
| |
| nonPdxType->m_string = |
| pdxReader.readString("m_string"); // GenericValCompare |
| nonPdxType->m_date = pdxReader.readDate("m_dateTime"); // compareData |
| |
| nonPdxType->m_double = pdxReader.readDouble("m_double"); |
| |
| nonPdxType->m_doubleArray = pdxReader.readDoubleArray("m_doubleArray"); |
| nonPdxType->m_float = pdxReader.readFloat("m_float"); |
| nonPdxType->m_floatArray = pdxReader.readFloatArray("m_floatArray"); |
| nonPdxType->m_int16 = pdxReader.readShort("m_int16"); |
| nonPdxType->m_int32 = pdxReader.readInt("m_int32"); |
| nonPdxType->m_long = pdxReader.readLong("m_long"); |
| nonPdxType->m_int32Array = pdxReader.readIntArray("m_int32Array"); |
| nonPdxType->m_longArray = pdxReader.readLongArray("m_longArray"); |
| nonPdxType->m_int16Array = pdxReader.readShortArray("m_int16Array"); |
| nonPdxType->m_sbyte = pdxReader.readByte("m_sbyte"); |
| nonPdxType->m_sbyteArray = pdxReader.readByteArray("m_sbyteArray"); |
| nonPdxType->m_stringArray = pdxReader.readStringArray("m_stringArray"); |
| nonPdxType->m_uint16 = pdxReader.readShort("m_uint16"); |
| nonPdxType->m_uint32 = pdxReader.readInt("m_uint32"); |
| nonPdxType->m_ulong = pdxReader.readLong("m_ulong"); |
| nonPdxType->m_uint32Array = pdxReader.readIntArray("m_uint32Array"); |
| nonPdxType->m_ulongArray = pdxReader.readLongArray("m_ulongArray"); |
| nonPdxType->m_uint16Array = pdxReader.readShortArray("m_uint16Array"); |
| |
| nonPdxType->m_byte252 = pdxReader.readByteArray("m_byte252"); |
| nonPdxType->m_byte253 = pdxReader.readByteArray("m_byte253"); |
| nonPdxType->m_byte65535 = pdxReader.readByteArray("m_byte65535"); |
| nonPdxType->m_byte65536 = pdxReader.readByteArray("m_byte65536"); |
| |
| nonPdxType->m_pdxEnum = pdxReader.readObject("m_pdxEnum"); |
| |
| nonPdxType->m_address = pdxReader.readObject("m_address"); |
| |
| nonPdxType->m_objectArray = pdxReader.readObjectArray("m_objectArray"); |
| |
| LOGINFO("TestPdxSerializer: NonPdxType fromData() Done."); |
| } catch (...) { |
| return nullptr; |
| } |
| return std::move(nonPdxType); |
| } |
| |
| bool toDataForAddress(const std::shared_ptr<const void>& testObject, |
| PdxWriter& pdxWriter) { |
| try { |
| auto nonPdxAddress = |
| std::static_pointer_cast<const PdxTests::NonPdxAddress>(testObject); |
| pdxWriter.writeInt("_aptNumber", nonPdxAddress->_aptNumber); |
| pdxWriter.writeString("_street", nonPdxAddress->_street); |
| pdxWriter.writeString("_city", nonPdxAddress->_city); |
| return true; |
| } catch (...) { |
| return false; |
| } |
| } |
| |
| bool toData(const std::shared_ptr<const void>& testObject, |
| const std::string& className, PdxWriter& pdxWriter) override { |
| ASSERT(className == CLASSNAME1 || className == CLASSNAME2, |
| "Unexpected classname in toData"); |
| |
| if (className == CLASSNAME2) { |
| return toDataForAddress(testObject, pdxWriter); |
| } |
| |
| auto nonPdxType = |
| std::static_pointer_cast<const PdxTests::NonPdxType>(testObject); |
| |
| try { |
| int* lengthArr = new int[2]; |
| |
| lengthArr[0] = 1; |
| lengthArr[1] = 2; |
| pdxWriter.writeArrayOfByteArrays( |
| "m_byteByteArray", nonPdxType->m_byteByteArray, 2, lengthArr); |
| pdxWriter.writeChar("m_char", nonPdxType->m_char); |
| pdxWriter.markIdentityField("m_char"); |
| pdxWriter.writeBoolean("m_bool", nonPdxType->m_bool); // 1 |
| pdxWriter.markIdentityField("m_bool"); |
| pdxWriter.writeBooleanArray("m_boolArray", nonPdxType->m_boolArray); |
| pdxWriter.markIdentityField("m_boolArray"); |
| pdxWriter.writeByte("m_byte", nonPdxType->m_byte); |
| pdxWriter.markIdentityField("m_byte"); |
| pdxWriter.writeByteArray("m_byteArray", nonPdxType->m_byteArray); |
| pdxWriter.markIdentityField("m_byteArray"); |
| pdxWriter.writeCharArray("m_charArray", nonPdxType->m_charArray); |
| pdxWriter.markIdentityField("m_charArray"); |
| pdxWriter.writeObject("m_arraylist", nonPdxType->m_arraylist); |
| pdxWriter.markIdentityField("m_arraylist"); |
| pdxWriter.writeObject("m_map", nonPdxType->m_map); |
| pdxWriter.markIdentityField("m_map"); |
| pdxWriter.writeObject("m_hashtable", nonPdxType->m_hashtable); |
| pdxWriter.markIdentityField("m_hashtable"); |
| pdxWriter.writeObject("m_vector", nonPdxType->m_vector); |
| pdxWriter.markIdentityField("m_vector"); |
| pdxWriter.writeObject("m_chs", nonPdxType->m_chs); |
| pdxWriter.markIdentityField("m_chs"); |
| pdxWriter.writeObject("m_clhs", nonPdxType->m_clhs); |
| pdxWriter.markIdentityField("m_clhs"); |
| pdxWriter.writeString("m_string", nonPdxType->m_string); |
| pdxWriter.markIdentityField("m_string"); |
| pdxWriter.writeDate("m_dateTime", nonPdxType->m_date); |
| pdxWriter.markIdentityField("m_dateTime"); |
| pdxWriter.writeDouble("m_double", nonPdxType->m_double); |
| pdxWriter.markIdentityField("m_double"); |
| pdxWriter.writeDoubleArray("m_doubleArray", nonPdxType->m_doubleArray); |
| pdxWriter.markIdentityField("m_doubleArray"); |
| pdxWriter.writeFloat("m_float", nonPdxType->m_float); |
| pdxWriter.markIdentityField("m_float"); |
| pdxWriter.writeFloatArray("m_floatArray", nonPdxType->m_floatArray); |
| pdxWriter.markIdentityField("m_floatArray"); |
| pdxWriter.writeShort("m_int16", nonPdxType->m_int16); |
| pdxWriter.markIdentityField("m_int16"); |
| pdxWriter.writeInt("m_int32", nonPdxType->m_int32); |
| pdxWriter.markIdentityField("m_int32"); |
| pdxWriter.writeLong("m_long", nonPdxType->m_long); |
| pdxWriter.markIdentityField("m_long"); |
| pdxWriter.writeIntArray("m_int32Array", nonPdxType->m_int32Array); |
| pdxWriter.markIdentityField("m_int32Array"); |
| pdxWriter.writeLongArray("m_longArray", nonPdxType->m_longArray); |
| pdxWriter.markIdentityField("m_longArray"); |
| pdxWriter.writeShortArray("m_int16Array", nonPdxType->m_int16Array); |
| pdxWriter.markIdentityField("m_int16Array"); |
| pdxWriter.writeByte("m_sbyte", nonPdxType->m_sbyte); |
| pdxWriter.markIdentityField("m_sbyte"); |
| pdxWriter.writeByteArray("m_sbyteArray", nonPdxType->m_sbyteArray); |
| pdxWriter.markIdentityField("m_sbyteArray"); |
| |
| int* strlengthArr = new int[2]; |
| |
| strlengthArr[0] = 5; |
| strlengthArr[1] = 5; |
| pdxWriter.writeStringArray("m_stringArray", nonPdxType->m_stringArray); |
| pdxWriter.markIdentityField("m_stringArray"); |
| pdxWriter.writeShort("m_uint16", nonPdxType->m_uint16); |
| pdxWriter.markIdentityField("m_uint16"); |
| pdxWriter.writeInt("m_uint32", nonPdxType->m_uint32); |
| pdxWriter.markIdentityField("m_uint32"); |
| pdxWriter.writeLong("m_ulong", nonPdxType->m_ulong); |
| pdxWriter.markIdentityField("m_ulong"); |
| pdxWriter.writeIntArray("m_uint32Array", nonPdxType->m_uint32Array); |
| pdxWriter.markIdentityField("m_uint32Array"); |
| pdxWriter.writeLongArray("m_ulongArray", nonPdxType->m_ulongArray); |
| pdxWriter.markIdentityField("m_ulongArray"); |
| pdxWriter.writeShortArray("m_uint16Array", nonPdxType->m_uint16Array); |
| pdxWriter.markIdentityField("m_uint16Array"); |
| |
| pdxWriter.writeByteArray("m_byte252", nonPdxType->m_byte252); |
| pdxWriter.markIdentityField("m_byte252"); |
| pdxWriter.writeByteArray("m_byte253", nonPdxType->m_byte253); |
| pdxWriter.markIdentityField("m_byte253"); |
| pdxWriter.writeByteArray("m_byte65535", nonPdxType->m_byte65535); |
| pdxWriter.markIdentityField("m_byte65535"); |
| pdxWriter.writeByteArray("m_byte65536", nonPdxType->m_byte65536); |
| pdxWriter.markIdentityField("m_byte65536"); |
| |
| pdxWriter.writeObject("m_pdxEnum", nonPdxType->m_pdxEnum); |
| pdxWriter.markIdentityField("m_pdxEnum"); |
| |
| pdxWriter.writeObject("m_address", nonPdxType->m_objectArray); |
| pdxWriter.writeObjectArray("m_objectArray", nonPdxType->m_objectArray); |
| |
| LOG("TestPdxSerializer: NonPdxType toData() Done......"); |
| } catch (...) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| } // namespace |
| |
| #endif // GEODE_INTEGRATION_TEST_THINCLIENTPDXSERIALIZERS_H_ |
