| /* |
| * 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. |
| */ |
| /* |
| * PdxObject.cpp |
| * |
| * Created on: Sep 29, 2011 |
| * Author: npatel |
| */ |
| |
| #include "PdxType.hpp" |
| |
| namespace PdxTests { |
| |
| template <typename T1, typename T2> |
| bool PdxTests::PdxType::genericValCompare(T1 value1, T2 value2) const { |
| if (value1 != value2) return false; |
| LOGINFO("PdxObject::genericValCompare Line_19"); |
| return true; |
| } |
| |
| template <typename T1, typename T2, typename L> |
| bool PdxTests::PdxType::genericCompare(T1* value1, T2* value2, L length) const { |
| L i = 0; |
| while (i < length) { |
| if (value1[i] != value2[i]) { |
| return false; |
| } else { |
| i++; |
| } |
| } |
| LOGINFO("PdxObject::genericCompare Line_34"); |
| return true; |
| } |
| |
| template <typename T1, typename T2> |
| bool PdxTests::PdxType::generic2DCompare(T1** value1, T2** value2, int length, |
| int* arrLengths) const { |
| LOGINFO("generic2DCompare length = %d ", length); |
| LOGINFO("generic2DCompare value1 = %d \t value2", value1[0][0], value2[0][0]); |
| LOGINFO("generic2DCompare value1 = %d \t value2", value1[1][0], value2[1][0]); |
| LOGINFO("generic2DCompare value1 = %d \t value2", value1[1][1], value2[1][1]); |
| for (int j = 0; j < length; j++) { |
| LOGINFO("generic2DCompare arrlength0 = %d ", arrLengths[j]); |
| for (int k = 0; k < arrLengths[j]; k++) { |
| LOGINFO("generic2DCompare arrlength = %d ", arrLengths[j]); |
| LOGINFO("generic2DCompare value1 = %d \t value2 = %d ", value1[j][k], |
| value2[j][k]); |
| if (value1[j][k] != value2[j][k]) return false; |
| } |
| } |
| LOGINFO("PdxObject::genericCompare Line_34"); |
| return true; |
| } |
| |
| // PdxType::~PdxObject() { |
| //} |
| |
| void PdxTests::PdxType::toData(PdxWriter& pw) const { |
| std::vector<int> lengths(2); |
| |
| lengths[0] = 1; |
| lengths[1] = 2; |
| pw.writeArrayOfByteArrays("m_byteByteArray", m_byteByteArray, 2, |
| lengths.data()); |
| pw.writeChar("m_char", m_char); |
| pw.markIdentityField("m_char"); |
| pw.writeBoolean("m_bool", m_bool); // 1 |
| pw.markIdentityField("m_bool"); |
| pw.writeBooleanArray("m_boolArray", m_boolArray); |
| pw.markIdentityField("m_boolArray"); |
| pw.writeByte("m_byte", m_byte); |
| pw.markIdentityField("m_byte"); |
| pw.writeByteArray("m_byteArray", m_byteArray); |
| pw.markIdentityField("m_byteArray"); |
| pw.writeCharArray("m_charArray", m_charArray); |
| pw.markIdentityField("m_charArray"); |
| pw.writeObject("m_arraylist", m_arraylist); |
| pw.writeObject("m_linkedlist", m_linkedlist); |
| pw.markIdentityField("m_arraylist"); |
| pw.writeObject("m_map", m_map); |
| pw.markIdentityField("m_map"); |
| pw.writeObject("m_hashtable", m_hashtable); |
| pw.markIdentityField("m_hashtable"); |
| pw.writeObject("m_vector", m_vector); |
| pw.markIdentityField("m_vector"); |
| pw.writeObject("m_chs", m_chs); |
| pw.markIdentityField("m_chs"); |
| pw.writeObject("m_clhs", m_clhs); |
| pw.markIdentityField("m_clhs"); |
| pw.writeString("m_string", m_string); |
| pw.markIdentityField("m_string"); |
| pw.writeDate("m_dateTime", m_date); |
| pw.markIdentityField("m_dateTime"); |
| pw.writeDouble("m_double", m_double); |
| pw.markIdentityField("m_double"); |
| pw.writeDoubleArray("m_doubleArray", m_doubleArray); |
| pw.markIdentityField("m_doubleArray"); |
| pw.writeFloat("m_float", m_float); |
| pw.markIdentityField("m_float"); |
| pw.writeFloatArray("m_floatArray", m_floatArray); |
| pw.markIdentityField("m_floatArray"); |
| pw.writeShort("m_int16", m_int16); |
| pw.markIdentityField("m_int16"); |
| pw.writeInt("m_int32", m_int32); |
| pw.markIdentityField("m_int32"); |
| pw.writeLong("m_long", m_long); |
| pw.markIdentityField("m_long"); |
| pw.writeIntArray("m_int32Array", m_int32Array); |
| pw.markIdentityField("m_int32Array"); |
| pw.writeLongArray("m_longArray", m_longArray); |
| pw.markIdentityField("m_longArray"); |
| pw.writeShortArray("m_int16Array", m_int16Array); |
| pw.markIdentityField("m_int16Array"); |
| pw.writeByte("m_sbyte", m_sbyte); |
| pw.markIdentityField("m_sbyte"); |
| pw.writeByteArray("m_sbyteArray", m_sbyteArray); |
| pw.markIdentityField("m_sbyteArray"); |
| |
| // int* strlengthArr = new int[2]; |
| |
| // strlengthArr[0] = 5; |
| // strlengthArr[1] = 5; |
| pw.writeStringArray("m_stringArray", m_stringArray); |
| pw.markIdentityField("m_stringArray"); |
| pw.writeShort("m_uint16", m_uint16); |
| pw.markIdentityField("m_uint16"); |
| pw.writeInt("m_uint32", m_uint32); |
| pw.markIdentityField("m_uint32"); |
| pw.writeLong("m_ulong", m_ulong); |
| pw.markIdentityField("m_ulong"); |
| pw.writeIntArray("m_uint32Array", m_uint32Array); |
| pw.markIdentityField("m_uint32Array"); |
| pw.writeLongArray("m_ulongArray", m_ulongArray); |
| pw.markIdentityField("m_ulongArray"); |
| pw.writeShortArray("m_uint16Array", m_uint16Array); |
| pw.markIdentityField("m_uint16Array"); |
| |
| pw.writeByteArray("m_byte252", m_byte252); |
| pw.markIdentityField("m_byte252"); |
| pw.writeByteArray("m_byte253", m_byte253); |
| pw.markIdentityField("m_byte253"); |
| pw.writeByteArray("m_byte65535", m_byte65535); |
| pw.markIdentityField("m_byte65535"); |
| pw.writeByteArray("m_byte65536", m_byte65536); |
| pw.markIdentityField("m_byte65536"); |
| |
| pw.writeObject("m_pdxEnum", m_pdxEnum); |
| pw.markIdentityField("m_pdxEnum"); |
| pw.writeObject("m_address", m_objectArray); |
| |
| pw.writeObjectArray("m_objectArray", m_objectArray); |
| pw.writeObjectArray("", m_objectArrayEmptyPdxFieldName); |
| |
| LOGDEBUG("PdxObject::writeObject() for enum Done......"); |
| |
| LOGDEBUG("PdxObject::toData() Done......"); |
| } |
| |
| void PdxTests::PdxType::fromData(PdxReader& pr) { |
| int32_t* Lengtharr; |
| int32_t arrLen = 0; |
| deleteByteByteArray(); |
| m_byteByteArray = |
| pr.readArrayOfByteArrays("m_byteByteArray", arrLen, &Lengtharr); |
| _GEODE_SAFE_DELETE_ARRAY(Lengtharr); |
| // TODO::need to write compareByteByteArray() and check for m_byteByteArray |
| // elements |
| |
| m_char = pr.readChar("m_char"); |
| // GenericValCompare |
| |
| m_bool = pr.readBoolean("m_bool"); |
| // GenericValCompare |
| m_boolArray = pr.readBooleanArray("m_boolArray"); |
| |
| m_byte = pr.readByte("m_byte"); |
| m_byteArray = pr.readByteArray("m_byteArray"); |
| m_charArray = pr.readCharArray("m_charArray"); |
| |
| m_arraylist = std::dynamic_pointer_cast<CacheableArrayList>( |
| pr.readObject("m_arraylist")); |
| m_linkedlist = std::dynamic_pointer_cast<CacheableLinkedList>( |
| pr.readObject("m_linkedlist")); |
| m_map = std::dynamic_pointer_cast<CacheableHashMap>(pr.readObject("m_map")); |
| // TODO:Check for the size |
| |
| m_hashtable = std::dynamic_pointer_cast<CacheableHashTable>( |
| pr.readObject("m_hashtable")); |
| // TODO:Check for the size |
| |
| m_vector = |
| std::dynamic_pointer_cast<CacheableVector>(pr.readObject("m_vector")); |
| // TODO::Check for size |
| |
| m_chs = std::dynamic_pointer_cast<CacheableHashSet>(pr.readObject("m_chs")); |
| // TODO::Size check |
| |
| m_clhs = std::dynamic_pointer_cast<CacheableLinkedHashSet>( |
| pr.readObject("m_clhs")); |
| // TODO:Size check |
| |
| m_string = pr.readString("m_string"); // GenericValCompare |
| m_date = pr.readDate("m_dateTime"); // compareData |
| |
| m_double = pr.readDouble("m_double"); |
| |
| m_doubleArray = pr.readDoubleArray("m_doubleArray"); |
| m_float = pr.readFloat("m_float"); |
| m_floatArray = pr.readFloatArray("m_floatArray"); |
| m_int16 = pr.readShort("m_int16"); |
| m_int32 = pr.readInt("m_int32"); |
| m_long = pr.readLong("m_long"); |
| m_int32Array = pr.readIntArray("m_int32Array"); |
| m_longArray = pr.readLongArray("m_longArray"); |
| m_int16Array = pr.readShortArray("m_int16Array"); |
| m_sbyte = pr.readByte("m_sbyte"); |
| m_sbyteArray = pr.readByteArray("m_sbyteArray"); |
| m_stringArray = pr.readStringArray("m_stringArray"); |
| m_uint16 = pr.readShort("m_uint16"); |
| m_uint32 = pr.readInt("m_uint32"); |
| m_ulong = pr.readLong("m_ulong"); |
| m_uint32Array = pr.readIntArray("m_uint32Array"); |
| m_ulongArray = pr.readLongArray("m_ulongArray"); |
| m_uint16Array = pr.readShortArray("m_uint16Array"); |
| // LOGINFO("PdxType::readInt() start..."); |
| |
| m_byte252 = pr.readByteArray("m_byte252"); |
| m_byte253 = pr.readByteArray("m_byte253"); |
| m_byte65535 = pr.readByteArray("m_byte65535"); |
| m_byte65536 = pr.readByteArray("m_byte65536"); |
| // TODO:Check for size |
| |
| m_pdxEnum = pr.readObject("m_pdxEnum"); |
| |
| m_address = pr.readObject("m_address"); |
| // size chaeck |
| |
| m_objectArray = pr.readObjectArray("m_objectArray"); |
| m_objectArrayEmptyPdxFieldName = pr.readObjectArray(""); |
| |
| // Check for individual elements |
| |
| // TODO:temp added delete it later |
| |
| LOGINFO("PdxObject::readObject() for enum Done..."); |
| } |
| std::string PdxTests::PdxType::toString() const { |
| char idbuf[1024]; |
| // sprintf(idbuf,"PdxObject: [ m_bool=%d ] [m_byte=%d] [m_int16=%d] |
| // [m_int32=%d] [m_float=%f] [m_double=%lf] [ m_string=%s ]",m_bool, m_byte, |
| // m_int16, m_int32, m_float, m_double, m_string); |
| sprintf(idbuf, "PdxObject:[m_int32=%d]", m_int32); |
| return idbuf; |
| } |
| |
| bool PdxTests::PdxType::equals(PdxTests::PdxType& other, |
| bool isPdxReadSerialized) const { |
| PdxType* ot = dynamic_cast<PdxType*>(&other); |
| if (!ot) { |
| return false; |
| } |
| if (ot == this) { |
| return true; |
| } |
| genericValCompare(ot->m_int32, m_int32); |
| genericValCompare(ot->m_bool, m_bool); |
| genericValCompare(ot->m_byte, m_byte); |
| genericValCompare(ot->m_int16, m_int16); |
| genericValCompare(ot->m_long, m_long); |
| genericValCompare(ot->m_float, m_float); |
| genericValCompare(ot->m_double, m_double); |
| genericValCompare(ot->m_sbyte, m_sbyte); |
| genericValCompare(ot->m_uint16, m_uint16); |
| genericValCompare(ot->m_uint32, m_uint32); |
| genericValCompare(ot->m_ulong, m_ulong); |
| genericValCompare(ot->m_char, m_char); |
| if (ot->m_string != m_string) { |
| return false; |
| } |
| genericCompare(ot->m_byteArray.data(), m_byteArray.data(), |
| m_byteArray.size()); |
| genericCompare(ot->m_int16Array.data(), m_int16Array.data(), |
| m_int16Array.size()); |
| genericCompare(ot->m_int32Array.data(), m_int32Array.data(), |
| m_int32Array.size()); |
| genericCompare(ot->m_longArray.data(), m_longArray.data(), |
| m_longArray.size()); |
| genericCompare(ot->m_uint32Array.data(), m_uint32Array.data(), |
| m_uint32Array.size()); |
| genericCompare(ot->m_ulongArray.data(), m_ulongArray.data(), |
| m_ulongArray.size()); |
| genericCompare(ot->m_uint16Array.data(), m_uint16Array.data(), |
| m_uint16Array.size()); |
| genericCompare(ot->m_sbyteArray.data(), m_sbyteArray.data(), |
| m_sbyteArray.size()); |
| genericCompare(ot->m_charArray.data(), m_charArray.data(), |
| m_charArray.size()); |
| // generic2DCompare(ot->m_byteByteArray, m_byteByteArray, byteByteArrayLen, |
| // lengthArr); |
| |
| if (!isPdxReadSerialized) { |
| for (size_t i = 0; i < m_objectArray->size(); i++) { |
| Address* otherAddr1 = |
| dynamic_cast<Address*>(ot->m_objectArray->at(i).get()); |
| Address* myAddr1 = dynamic_cast<Address*>(m_objectArray->at(i).get()); |
| if (!otherAddr1->equals(*myAddr1)) return false; |
| } |
| LOGINFO("PdxObject::equals isPdxReadSerialized = %d", isPdxReadSerialized); |
| } |
| |
| // m_objectArrayEmptyPdxFieldName |
| if (!isPdxReadSerialized) { |
| for (size_t i = 0; i < m_objectArrayEmptyPdxFieldName->size(); i++) { |
| Address* otherAddr1 = |
| dynamic_cast<Address*>(ot->m_objectArray->at(i).get()); |
| Address* myAddr1 = dynamic_cast<Address*>(m_objectArray->at(i).get()); |
| if (!otherAddr1->equals(*myAddr1)) return false; |
| } |
| LOGINFO("PdxObject::equals Empty Field Name isPdxReadSerialized = %d", |
| isPdxReadSerialized); |
| } |
| |
| auto myenum = std::dynamic_pointer_cast<CacheableEnum>(m_pdxEnum); |
| auto otenum = std::dynamic_pointer_cast<CacheableEnum>(ot->m_pdxEnum); |
| if (myenum->getEnumOrdinal() != otenum->getEnumOrdinal()) return false; |
| if (myenum->getEnumClassName() != otenum->getEnumClassName()) return false; |
| if (myenum->getEnumName() != otenum->getEnumName()) return false; |
| |
| genericValCompare(ot->m_arraylist->size(), m_arraylist->size()); |
| for (size_t k = 0; k < m_arraylist->size(); k++) { |
| genericValCompare(ot->m_arraylist->at(k), m_arraylist->at(k)); |
| } |
| |
| LOGINFO("Equals Linked List Starts"); |
| genericValCompare(ot->m_linkedlist->size(), m_linkedlist->size()); |
| for (size_t k = 0; k < m_linkedlist->size(); k++) { |
| genericValCompare(ot->m_linkedlist->at(k), m_linkedlist->at(k)); |
| } |
| LOGINFO("Equals Linked List Finished"); |
| |
| genericValCompare(ot->m_vector->size(), m_vector->size()); |
| for (size_t j = 0; j < m_vector->size(); j++) { |
| genericValCompare(ot->m_vector->at(j), m_vector->at(j)); |
| } |
| |
| LOGINFO("PdxObject::equals DOne Line_201"); |
| return true; |
| } |
| |
| } // namespace PdxTests |