You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@geode.apache.org by GitBox <gi...@apache.org> on 2022/01/19 15:16:07 UTC
[GitHub] [geode-native] gaussianrecurrence opened a new pull request #910: GEODE-9968: Fix new attrs in PdxSerializable
gaussianrecurrence opened a new pull request #910:
URL: https://github.com/apache/geode-native/pull/910
- Solved addition of attributes for previously defined PdxSerializable
implementations, which was not working before.
- Added a new IT to verify that it's possible to add a new attribute
under all scenarios.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@geode.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [geode-native] pivotal-jbarrett commented on a change in pull request #910: GEODE-9968: Fix new attrs in PdxSerializable
Posted by GitBox <gi...@apache.org>.
pivotal-jbarrett commented on a change in pull request #910:
URL: https://github.com/apache/geode-native/pull/910#discussion_r787880338
##########
File path: cppcache/integration/test/PdxSerializableTest.cpp
##########
@@ -0,0 +1,178 @@
+/*
+ * 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 <framework/Cluster.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+#include <random>
+
+#include <gtest/gtest.h>
+
+#include <geode/Cache.hpp>
+#include <geode/CacheableDate.hpp>
+#include <geode/EntryEvent.hpp>
+#include <geode/PdxWrapper.hpp>
+#include <geode/PoolManager.hpp>
+#include <geode/RegionEvent.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+
+#include "CacheImpl.hpp"
+#include "CacheRegionHelper.hpp"
+#include "testobject/PdxType.hpp"
+
+namespace {
+
+using apache::geode::client::Cache;
+using apache::geode::client::CacheableDate;
+using apache::geode::client::CacheableString;
+using apache::geode::client::CacheFactory;
+using apache::geode::client::CacheRegionHelper;
+using apache::geode::client::PdxReader;
+using apache::geode::client::PdxSerializable;
+using apache::geode::client::Region;
+using apache::geode::client::RegionEvent;
+using apache::geode::client::RegionShortcut;
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Return;
+
+using PdxTests::DynamicFieldsType;
+
+namespace {
+constexpr auto DYNAMIC_FIELDS_TYPE_MODIFIERS_COUNT = 22;
+std::function<void(DynamicFieldsType&)>
+ DYNAMIC_FIELDS_TYPE_MODIFIERS[DYNAMIC_FIELDS_TYPE_MODIFIERS_COUNT] = {
+ [](DynamicFieldsType& obj) { obj.setChar('a'); },
+ [](DynamicFieldsType& obj) { obj.setBoolean(false); },
+ [](DynamicFieldsType& obj) { obj.setByte(1); },
+ [](DynamicFieldsType& obj) { obj.setShort(2); },
+ [](DynamicFieldsType& obj) { obj.setInt(3); },
+ [](DynamicFieldsType& obj) { obj.setLong(5); },
+ [](DynamicFieldsType& obj) { obj.setFloat(8.f); },
+ [](DynamicFieldsType& obj) { obj.setDouble(13.); },
+ [](DynamicFieldsType& obj) { obj.setString("Test string"); },
+ [](DynamicFieldsType& obj) {
+ obj.setDate(CacheableDate::create(CacheableDate::clock::now()));
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setDate(CacheableDate::create(CacheableDate::clock::now()));
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setObject(CacheableString::create("An object string"));
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setCharArray({'a', 'b', 'c'});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setBooleanArray({false, true, false});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setByteArray({21, 34, 55});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setByteArray({21, 34, 55});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setShortArray({89, 144, 233});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setIntArray({377, 610, 987});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setLongArray({1597, 2584, 4181});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setFloatArray({7402.f, 11583.f, 18985.f});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setDoubleArray({30568., 49553., 80121.});
+ },
+ [](DynamicFieldsType& obj) {
+ obj.setStringArray({"A test string", "Another test string",
+ "Yet another test string"});
+ },
+};
+} // namespace
+
+Cache createTestCache() {
+ CacheFactory cacheFactory;
+ return cacheFactory.set("log-level", "none")
+ .set("statistic-sampling-enabled", "false")
+ .create();
+}
+
+TEST(PdxSerializableTest, deserializeNewFields) {
+ Cluster cluster{LocatorCount{1}, ServerCount{1}};
+ cluster.start();
+
+ auto& gfsh = cluster.getGfsh();
+ gfsh.create().region().withName("region").withType("REPLICATE").execute();
+
+ auto cache = createTestCache();
+ {
+ auto poolFactory = cache.getPoolManager().createFactory();
+ cluster.applyLocators(poolFactory);
+ poolFactory.create("default");
+ }
+
+ auto region = cache.createRegionFactory(RegionShortcut::CACHING_PROXY)
+ .setPoolName("default")
+ .create("region");
+
+ cache.getTypeRegistry().registerPdxType(
+ DynamicFieldsType::createDeserializable);
+
+ auto entry = std::make_shared<DynamicFieldsType>(2, "Line 1", "Line 2");
+ region->put("1", entry);
+
+ auto entryFetched = region->get("1");
+ ASSERT_TRUE(entryFetched);
+
+ auto address = std::dynamic_pointer_cast<DynamicFieldsType>(entryFetched);
+ ASSERT_TRUE(address);
+
+ ASSERT_EQ(*entry, *address);
+
+ // This mechanism guarantees that a different set of fields
+ // are introduced each execution in order ensure a proper behaviour
+ std::mt19937 generator{std::random_device{}()};
+ std::uniform_int_distribution<uint32_t> distribution(
+ 1, 1 << DYNAMIC_FIELDS_TYPE_MODIFIERS_COUNT);
+
+ entry = std::make_shared<DynamicFieldsType>(3, "Line 1", "Line 2");
+ auto mask = distribution(generator);
+ for (auto i = 0; i < DYNAMIC_FIELDS_TYPE_MODIFIERS_COUNT; ++i) {
+ if ((mask & (1ULL << i)) != 0) {
+ DYNAMIC_FIELDS_TYPE_MODIFIERS[i](*entry);
+ }
+ }
+
+ region->put("2", entry);
+
+ entryFetched = region->get("2");
+ ASSERT_TRUE(entryFetched);
+
+ address = std::dynamic_pointer_cast<DynamicFieldsType>(entryFetched);
+ ASSERT_TRUE(address);
+
+ ASSERT_EQ(*entry, *address);
+}
+
+} // namespace
Review comment:
Trailing new line needed.
##########
File path: cppcache/src/PdxRemoteReader.cpp
##########
@@ -34,571 +34,391 @@ PdxRemoteReader::~PdxRemoteReader() {
}
char16_t PdxRemoteReader::readChar(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2:
- return PdxLocalReader::readChar(fieldName); // in same order
- case -1: {
- return '\0'; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- auto retVal = PdxLocalReader::readChar(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return '\0';
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readChar(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
bool PdxRemoteReader::readBoolean(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readBoolean(fieldName); // in same order
- }
- case -1: {
- return 0; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- bool retVal = PdxLocalReader::readBoolean(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- } else {
- return 0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return false;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ bool result = PdxLocalReader::readBoolean(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
int8_t PdxRemoteReader::readByte(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readByte(fieldName); // in same order
- }
- case -1: {
- return 0;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- int8_t retValue;
- retValue = PdxLocalReader::readByte(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retValue;
- } else {
- return 0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readByte(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
int16_t PdxRemoteReader::readShort(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readShort(fieldName); // in same order
- }
- case -1: {
- return 0; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- int16_t value;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- value = PdxLocalReader::readShort(fieldName);
- PdxLocalReader::resettoPdxHead();
- return value;
- } else {
- return 0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readShort(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
int32_t PdxRemoteReader::readInt(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readInt(fieldName); // in same order
- }
- case -1: {
- return 0; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- int32_t value;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- value = PdxLocalReader::readInt(fieldName);
- PdxLocalReader::resettoPdxHead();
- return value;
- } else {
- return 0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readInt(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
int64_t PdxRemoteReader::readLong(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readLong(fieldName); // in same order
- }
- case -1: {
- return 0; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- int64_t value;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- value = PdxLocalReader::readLong(fieldName);
- PdxLocalReader::resettoPdxHead();
- return value;
- } else {
- return 0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readLong(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
float PdxRemoteReader::readFloat(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readFloat(fieldName); // in same order
- }
- case -1: {
- return 0.0f; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- float value;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- value = PdxLocalReader::readFloat(fieldName);
- PdxLocalReader::resettoPdxHead();
- return value;
- } else {
- return 0.0f; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0.f;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readFloat(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
double PdxRemoteReader::readDouble(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readDouble(fieldName); // in same order
- }
- case -1: {
- return 0.0; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- double value;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- value = PdxLocalReader::readDouble(fieldName);
- PdxLocalReader::resettoPdxHead();
- return value;
- } else {
- return 0.0; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return 0.;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readDouble(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::string PdxRemoteReader::readString(const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readString(fieldName);
- }
- case -1: {
- return std::string();
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- auto retVal = PdxLocalReader::readString(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- } else {
- static std::string emptyString;
- return emptyString;
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readString(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::shared_ptr<Serializable> PdxRemoteReader::readObject(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readObject(fieldName); // in same order
- }
- case -1: {
- return nullptr;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- std::shared_ptr<Serializable> ptr;
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- ptr = PdxLocalReader::readObject(fieldName);
- PdxLocalReader::resettoPdxHead();
- return ptr;
- } else {
- return nullptr; // null value
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return nullptr;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readObject(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<char16_t> PdxRemoteReader::readCharArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<char16_t> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readCharArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readCharArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readCharArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<bool> PdxRemoteReader::readBooleanArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<bool> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readBooleanArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readBooleanArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readBooleanArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<int8_t> PdxRemoteReader::readByteArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<int8_t> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readByteArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readByteArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readByteArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<int16_t> PdxRemoteReader::readShortArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<int16_t> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readShortArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readShortArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readShortArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<int32_t> PdxRemoteReader::readIntArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<int32_t> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readIntArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readIntArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readIntArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<int64_t> PdxRemoteReader::readLongArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<int64_t> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readLongArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readLongArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readLongArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<float> PdxRemoteReader::readFloatArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<float> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readFloatArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readFloatArray(fieldName); // in same order
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readFloatArray(fieldName); // in same order
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<double> PdxRemoteReader::readDoubleArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- std::vector<double> array;
- switch (choice) {
- case -2: {
- array = PdxLocalReader::readDoubleArray(fieldName); // in same order
- break;
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- array = PdxLocalReader::readDoubleArray(fieldName); // in same order
- PdxLocalReader::resettoPdxHead();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
- return array;
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readDoubleArray(fieldName); // in same order
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::vector<std::string> PdxRemoteReader::readStringArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2: {
- return PdxLocalReader::readStringArray(fieldName);
- }
- case -1: {
- return std::vector<std::string>();
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- if (position != -1) {
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- auto strArray = PdxLocalReader::readStringArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- return strArray;
- } else {
- return std::vector<std::string>();
- }
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readStringArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+
+ return result;
}
std::shared_ptr<CacheableObjectArray> PdxRemoteReader::readObjectArray(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2:
- return PdxLocalReader::readObjectArray(fieldName); // in same order
- case -1: {
- return nullptr; // null value
- }
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- auto retVal = PdxLocalReader::readObjectArray(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return {};
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readObjectArray(fieldName);
+ PdxLocalReader::resettoPdxHead();
+ return result;
}
int8_t** PdxRemoteReader::readArrayOfByteArrays(const std::string& fieldName,
int32_t& arrayLength,
int32_t** elementLength) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2:
- return PdxLocalReader::readArrayOfByteArrays(
- fieldName, arrayLength, elementLength); // in same order
- case -1:
- return nullptr; // null value
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- int8_t** retVal = PdxLocalReader::readArrayOfByteArrays(
- fieldName, arrayLength, elementLength);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
+ return nullptr;
}
+
+ PdxLocalReader::resettoPdxHead();
+ m_dataInput->advanceCursor(position);
+
+ auto result = PdxLocalReader::readArrayOfByteArrays(fieldName, arrayLength,
+ elementLength);
+
+ PdxLocalReader::resettoPdxHead();
+ return result;
}
std::shared_ptr<CacheableDate> PdxRemoteReader::readDate(
const std::string& fieldName) {
- int choice = m_localToRemoteMap[m_currentIndex++];
-
- switch (choice) {
- case -2:
- return PdxLocalReader::readDate(fieldName); // in same order
- case -1:
- return nullptr;
- default: {
- // sequence id read field and then update
- int position = m_pdxType->getFieldPosition(
- choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
- PdxLocalReader::resettoPdxHead();
- m_dataInput->advanceCursor(position);
- auto retVal = PdxLocalReader::readDate(fieldName);
- PdxLocalReader::resettoPdxHead();
- return retVal;
- }
+ int position = m_pdxType->getFieldPosition(fieldName, m_offsetsBuffer,
+ m_offsetSize, m_serializedLength);
+
+ if (position == -1) {
Review comment:
I wonder, if with all this refactoring, we should define a `constexpr` for this `-1` sentinel value. If you make further changes I would suggest you do this too, otherwise something to keep in your mind for later.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscribe@geode.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org