| #pragma once |
| |
| #ifndef APACHE_GEODE_GUARD_9b6d34ac32115700916ecb8e4bf0d825 |
| #define APACHE_GEODE_GUARD_9b6d34ac32115700916ecb8e4bf0d825 |
| |
| /* |
| * 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 <gfcpp/PdxSerializable.hpp> |
| #include <gfcpp/GeodeCppCache.hpp> |
| #include <gfcpp/PdxWriter.hpp> |
| #include <gfcpp/PdxReader.hpp> |
| |
| #ifdef _WIN32 |
| #ifdef BUILD_TESTOBJECT |
| #define TESTOBJECT_EXPORT LIBEXP |
| #else |
| #define TESTOBJECT_EXPORT LIBIMP |
| #endif |
| #else |
| #define TESTOBJECT_EXPORT |
| #endif |
| |
| #define GFIGNORE(X) X |
| #define GFEXCLUDE |
| #define GFID |
| #define GFARRAYSIZE(X) |
| #define GFARRAYELEMSIZE(X) |
| |
| using namespace apache::geode::client; |
| |
| namespace AutoPdxTests { |
| |
| enum Gender { male, female, other }; |
| class GFIGNORE(TESTOBJECT_EXPORT) AutoPdxVersioned1 : public PdxSerializable { |
| private: |
| int8_t** m_byteByteArray; |
| wchar_t m_char; |
| bool m_bool; |
| bool* m_boolArray; |
| int8_t m_byte; |
| int8_t* m_byteArray; |
| wchar_t* m_charArray; |
| CacheableArrayListPtr m_arraylist; |
| CacheableHashMapPtr m_map; |
| char* m_string; |
| CacheableDatePtr m_date; |
| double m_double; |
| double* m_doubleArray; |
| float m_float; |
| float* m_floatArray; |
| int16_t m_int16; |
| int32_t m_int32; |
| int32_t* m_int32Array; |
| int64_t* m_longArray; |
| int16_t* m_int16Array; |
| int8_t m_sbyte; // |
| int8_t* m_sbyteArray; /// |
| char** m_stringArray; |
| int16_t m_uint16; /// |
| // int32_t m_uint32;/// |
| // int64_t m_long; |
| int64_t m_ulong; /// |
| int32_t* m_uint32Array; |
| int64_t* m_ulongArray; |
| int16_t* m_uint16Array; |
| int8_t *m_byte252, *m_byte253, *m_byte65535, *m_byte65536; |
| enum pdxEnumTest { pdx1, pdx2, pdx3, pdx4 }; |
| CacheablePtr m_pdxEnum; |
| // GFEXCLUDE double m_double1,m_double2; // bug #909 |
| // wchar_t pdxType_Wchar1; |
| // GFARRAYSIZE(pdxType_Wchar1) int32_t pdxType_pdxType_Wchar1_Size; // bug |
| // #908 |
| |
| GFARRAYSIZE(m_boolArray) int32_t boolArrayLen; |
| GFARRAYSIZE(m_charArray) int32_t charArrayLen; |
| GFARRAYSIZE(m_byteArray) int32_t byteArrayLen; |
| GFARRAYSIZE(m_sbyteArray) int32_t shortArrayLen; |
| GFARRAYSIZE(m_int16Array) int32_t int16Array; |
| GFARRAYSIZE(m_uint16Array) int32_t uint16Array; |
| GFARRAYSIZE(m_int32Array) int32_t intArrayLen; |
| GFARRAYSIZE(m_uint32Array) int32_t uintArrayLen; |
| GFARRAYSIZE(m_longArray) int32_t longArrayLen; |
| GFARRAYSIZE(m_ulongArray) int32_t ulongArrayLen; |
| GFARRAYSIZE(m_doubleArray) int32_t doubleArrayLen; |
| GFARRAYSIZE(m_floatArray) int32_t floatArrayLen; |
| GFARRAYSIZE(m_stringArray) int32_t strLenArray; |
| GFARRAYSIZE(m_byte252) int32_t m_byte252Len; |
| GFARRAYSIZE(m_byte253) int32_t m_byte253Len; |
| GFARRAYSIZE(m_byte65535) int32_t m_byte65535Len; |
| GFARRAYSIZE(m_byte65536) int32_t m_byte65536Len; |
| GFARRAYSIZE(m_byteByteArray) int32_t byteByteArrayLen; |
| GFARRAYELEMSIZE(m_byteByteArray) int* lengthArr; |
| // GFARRAYSIZE(m_wideparentArrayName) int32_t wideparentArrayNameLen; |
| // int* lengthArr; |
| |
| public: |
| /* AutoPdxVersioned1(const char* key) { |
| LOGINFO("rjk:inside testobject pdxType"); |
| init(key); |
| }*/ |
| AutoPdxVersioned1() { init("def"); } |
| AutoPdxVersioned1(const char* key); |
| void init(const char* key); |
| inline bool compareBool(bool b, bool b2) { |
| if (b == b2) return b; |
| throw IllegalStateException("Not got expected value for bool type: "); |
| } |
| |
| virtual ~AutoPdxVersioned1() {} |
| |
| virtual uint32_t objectSize() const { |
| uint32_t objectSize = sizeof(AutoPdxVersioned1); |
| return objectSize; |
| } |
| // void checkNullAndDelete(void *data); |
| wchar_t getChar() { return m_char; } |
| |
| wchar_t* getCharArray() { return m_charArray; } |
| |
| int8_t** getArrayOfByteArrays() { return m_byteByteArray; } |
| |
| bool getBool() { return m_bool; } |
| |
| CacheableHashMapPtr getHashMap() { return m_map; } |
| |
| int8_t getSByte() { return m_sbyte; } |
| |
| int16_t getUint16() { return m_uint16; } |
| |
| // int32_t getUInt() { |
| // return m_uint32; |
| //} |
| |
| int64_t getULong() { return m_ulong; } |
| |
| int16_t* getUInt16Array() { return m_uint16Array; } |
| |
| int32_t* getUIntArray() { return m_uint32Array; } |
| |
| int64_t* getULongArray() { return m_ulongArray; } |
| |
| int8_t* getByte252() { return m_byte252; } |
| |
| int8_t* getByte253() { return m_byte253; } |
| |
| int8_t* getByte65535() { return m_byte65535; } |
| |
| int8_t* getByte65536() { return m_byte65536; } |
| |
| int8_t* getSByteArray() { return m_sbyteArray; } |
| |
| CacheableEnumPtr getEnum() { return m_pdxEnum; } |
| CacheableArrayListPtr getArrayList() { return m_arraylist; } |
| |
| int8_t getByte() { return m_byte; } |
| |
| int16_t getShort() { return m_int16; } |
| |
| int32_t getInt() { return m_int32; } |
| // int64_t getLong(){ |
| // return m_long; |
| // } |
| |
| float getFloat() { return m_float; } |
| |
| double getDouble() { return m_double; } |
| |
| const char* getString() { return m_string; } |
| |
| bool* getBoolArray() { return m_boolArray; } |
| |
| int8_t* getByteArray() { return m_byteArray; } |
| |
| int16_t* getShortArray() { return m_int16Array; } |
| |
| int32_t* getIntArray() { return m_int32Array; } |
| |
| int64_t* getLongArray() { return m_longArray; } |
| |
| double* getDoubleArray() { return m_doubleArray; } |
| |
| float* getFloatArray() { return m_floatArray; } |
| |
| char** getStringArray() { return m_stringArray; } |
| |
| CacheableDatePtr getDate() { return m_date; } |
| |
| int32_t getByteArrayLength() { return byteArrayLen; } |
| |
| int32_t getBoolArrayLength() { return boolArrayLen; } |
| |
| int32_t getShortArrayLength() { return shortArrayLen; } |
| |
| int32_t getStringArrayLength() { return strLenArray; } |
| |
| int32_t getIntArrayLength() { return intArrayLen; } |
| |
| int32_t getLongArrayLength() { return longArrayLen; } |
| |
| int32_t getFloatArrayLength() { return floatArrayLen; } |
| |
| int32_t getDoubleArrayLength() { return doubleArrayLen; } |
| |
| int32_t getbyteByteArrayLength() { return byteByteArrayLen; } |
| |
| int32_t getCharArrayLength() { return charArrayLen; } |
| |
| using PdxSerializable::toData; |
| using PdxSerializable::fromData; |
| |
| virtual void toData(PdxWriterPtr pw) /*const*/; |
| |
| virtual void fromData(PdxReaderPtr pr); |
| |
| CacheableStringPtr toString() const; |
| |
| const char* getClassName() const; |
| static PdxSerializable* createDeserializable(); |
| bool equals(AutoPdxTests::AutoPdxVersioned1& other, |
| bool isPdxReadSerialized) const; |
| |
| template <typename T1, typename T2> |
| bool genericValCompare(T1 value1, T2 value2) const; |
| |
| template <typename T1, typename T2> |
| bool genericCompare(T1* value1, T2* value2, int length) const; |
| |
| template <typename T1, typename T2> |
| bool generic2DCompare(T1** value1, T2** value2, int length, |
| int* arrLengths) const; |
| }; |
| typedef SharedPtr<AutoPdxTests::AutoPdxVersioned1> AutoPdxVersioned1Ptr; |
| |
| /************************************************************ |
| * PdxTypes1 |
| * *********************************************************/ |
| |
| class GFIGNORE(TESTOBJECT_EXPORT) PdxTypes1 : public PdxSerializable { |
| private: |
| int32_t m_i1; |
| int32_t m_i2; |
| int32_t m_i3; |
| int32_t m_i4; |
| const wchar_t* m_wideparentName; |
| wchar_t** m_wideparentArrayName; |
| CacheableEnumPtr m_enum; |
| GFARRAYSIZE(m_wideparentArrayName) int32_t wideparentArrayNameLen; |
| // int** int2DArray; |
| // GFARRAYSIZE(int2DArray) int32_t int2DArrayLen; |
| // GFARRAYELEMSIZE(int2DArray) int* intlengthArr; |
| public: |
| PdxTypes1(); |
| |
| virtual ~PdxTypes1(); |
| |
| int32_t getHashCode(); |
| |
| bool equals(PdxSerializablePtr obj); |
| |
| CacheableStringPtr toString() const; |
| |
| using PdxSerializable::toData; |
| using PdxSerializable::fromData; |
| |
| virtual void fromData(PdxReaderPtr pr); |
| |
| virtual void toData(PdxWriterPtr pw); |
| |
| const char* getClassName() const; |
| int32_t getm_i1() { return m_i1; } |
| static PdxSerializable* createDeserializable(); |
| const wchar_t* getWideParentName() { return m_wideparentName; } |
| wchar_t** getWideParentArrayName() { return m_wideparentArrayName; } |
| CacheableEnumPtr getPdxEnum() { return m_enum; } |
| }; |
| typedef SharedPtr<PdxTypes1> PdxTypes1Ptr; |
| |
| /************************************************************ |
| * PdxTypes2 |
| * *********************************************************/ |
| |
| class GFIGNORE(TESTOBJECT_EXPORT) PdxTypes2 : public PdxSerializable { |
| private: |
| char* m_s1; //"one" |
| int32_t m_i1; |
| int32_t m_i2; |
| int32_t m_i3; |
| int32_t m_i4; |
| // volatile int32_t m_i5; //for volatile #894 bug |
| public: |
| PdxTypes2(); |
| |
| virtual ~PdxTypes2(); |
| |
| int32_t getHashCode(); |
| |
| bool equals(PdxSerializablePtr obj); |
| |
| CacheableStringPtr toString() const; |
| |
| using PdxSerializable::toData; |
| using PdxSerializable::fromData; |
| |
| virtual void fromData(PdxReaderPtr pr); |
| |
| virtual void toData(PdxWriterPtr pw); |
| |
| const char* getClassName() const; |
| static PdxSerializable* createDeserializable(); |
| }; |
| typedef SharedPtr<PdxTypes2> PdxTypes2Ptr; |
| |
| class GFIGNORE(TESTOBJECT_EXPORT) NestedPdx : public PdxSerializable { |
| private: |
| PdxTypes1Ptr m_pd1; |
| PdxTypes2Ptr m_pd2; |
| char* m_s1; //"one" |
| char* m_s2; |
| int32_t m_i1; |
| int32_t m_i2; |
| int32_t m_i3; |
| int32_t m_i4; |
| |
| public: |
| NestedPdx(); |
| NestedPdx(char* key) { |
| m_pd1 = new PdxTypes1(); |
| m_pd2 = new PdxTypes2(); |
| size_t len = strlen("NestedPdx ") + strlen(key) + 1; |
| m_s1 = new char[len]; |
| strcpy(m_s1, "NestedPdx "); |
| strcat(m_s1, key); |
| m_s2 = (char*)("two"); |
| m_i1 = 34324; |
| m_i2 = 2144; |
| m_i3 = 4645734; |
| m_i4 = 73567; |
| } |
| virtual ~NestedPdx(); |
| |
| int32_t getHashCode(); |
| |
| bool equals(PdxSerializablePtr obj); |
| |
| CacheableStringPtr toString() const; |
| |
| using PdxSerializable::toData; |
| using PdxSerializable::fromData; |
| |
| virtual void fromData(PdxReaderPtr pr); |
| |
| virtual void toData(PdxWriterPtr pw); |
| |
| const char* getClassName() const; |
| const char* getString() { return m_s1; } |
| |
| static PdxSerializable* createDeserializable(); |
| }; |
| typedef SharedPtr<NestedPdx> NestedPdxPtr; |
| } // namespace AutoPdxTests |
| |
| #endif // APACHE_GEODE_GUARD_9b6d34ac32115700916ecb8e4bf0d825 |