diff --git a/CMakeLists.txt b/CMakeLists.txt
index 578b8978679e99bf5342adf6a7e5f5ed04538542..8d684da402ca704e30e1d7219a24accd0e5f1742 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,6 +37,7 @@ if (TRUE)
They are required to build the memory system (armem and related libraries). \
Please use this installation script to install libmongocxx and libbsoncxx:
cd ${PROJECT_SOURCE_DIR}/etc/mongocxx/ && ./install_mongocxx.sh ~/repos \
+ or run 'cmake -DCMAKE_PREFIX_PATH=$mongocxx_install_dir' if you have mongocxx already installed \
${ColourReset}")
endif()
endif()
diff --git a/source/RobotAPI/applications/AronCodeGenerator/main.cpp b/source/RobotAPI/applications/AronCodeGenerator/main.cpp
index fb8a2287f38cadcdbd71175a1e50ca171e7d5461..5da09c7a9a41abf9fca00adff864567125983938 100644
--- a/source/RobotAPI/applications/AronCodeGenerator/main.cpp
+++ b/source/RobotAPI/applications/AronCodeGenerator/main.cpp
@@ -39,15 +39,15 @@
#include <ArmarXCore/libraries/cppgen/CppMethod.h>
#include <ArmarXCore/libraries/cppgen/CppClass.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.h>
+#include <RobotAPI/libraries/aron/core/typereader/xml/Reader.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.h>
using namespace armarx;
using namespace aron;
-// Aron Code Generator Main Executable. This executable calls generates a aron code file out of a xml file.
-// 2020-11-12 It supports C++ Code generation
+/// Aron Code Generator Main Executable.
+/// This executable calls generates a aron code file out of an aron xml file.
int main(int argc, char* argv[])
{
try
@@ -131,7 +131,7 @@ int main(int argc, char* argv[])
std::cout << "Parsing the XML file..." << std::endl;
}
- xmltypereader::Reader reader;
+ typereader::xml::Reader reader;
reader.parseFile(input_file);
if (verbose)
{
@@ -140,11 +140,11 @@ int main(int argc, char* argv[])
std::cout << "--> They are: " << std::endl;
for (const auto& generateType : reader.getGenerateObjects())
{
- std::cout << "----> " << generateType->typeName << "( with " << generateType->nestedObjects.size() << " inner definitions)" << std::endl;
+ std::cout << "----> " << generateType.typeName << std::endl;
}
}
- cppserializer::Writer writer("AronTestSegment", reader.getCodeIncludes());
+ codegenerator::cpp::Writer writer("AronTestSegment", reader.getCodeIncludes());
if (verbose)
{
@@ -171,7 +171,7 @@ int main(int argc, char* argv[])
std::cout << "Now exporting classes..." << std::endl;
}
- CppWriterPtr w = CppWriterPtr(new CppWriter());
+ auto w = CppWriterPtr(new CppWriter());
CppClass::Write(classes, w);
std::string new_file_content = w->getString();
diff --git a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/CMakeLists.txt b/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/CMakeLists.txt
deleted file mode 100644
index f51802b6fb746ec770a1fd994d03b111d8e2324a..0000000000000000000000000000000000000000
--- a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/CMakeLists.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-armarx_component_set_name("SimpleEpisodicMemoryKinematicUnitConnector")
-
-
-set(COMPONENT_LIBS
- ArmarXCore
- ArmarXCoreInterfaces
-
-)
-
-set(SOURCES
- ./SimpleEpisodicMemoryKinematicUnitConnector.cpp
-#@TEMPLATE_LINE@@COMPONENT_PATH@/@COMPONENT_NAME@.cpp
-)
-set(HEADERS
- ./SimpleEpisodicMemoryKinematicUnitConnector.h
-#@TEMPLATE_LINE@@COMPONENT_PATH@/@COMPONENT_NAME@.h
-)
-
-
-armarx_add_component("${SOURCES}" "${HEADERS}")
-
-#find_package(MyLib QUIET)
-#armarx_build_if(MyLib_FOUND "MyLib not available")
-# all target_include_directories must be guarded by if(Xyz_FOUND)
-# for multiple libraries write: if(X_FOUND AND Y_FOUND)....
-#if(MyLib_FOUND)
-# target_include_directories(SimpleEpisodicMemoryKinematicUnitConnector PUBLIC ${MyLib_INCLUDE_DIRS})
-#endif()
-
-# add unit tests
-add_subdirectory(test)
diff --git a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.cpp b/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.cpp
deleted file mode 100644
index da712b4aba69056b7ef5dd1f3b9e4aa7663e0e88..0000000000000000000000000000000000000000
--- a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @package RobotAPI::ArmarXObjects::SimpleEpisodicMemoryKinematicUnitConnector
- * @author Fabian PK ( fabian dot peller-konrad at kit dot edu )
- * @date 2020
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include "SimpleEpisodicMemoryKinematicUnitConnector.h"
-
-
-namespace armarx
-{
-
- std::string SimpleEpisodicMemoryKinematicUnitConnector::getDefaultName() const
- {
- return "SimpleEpisodicMemoryKinematicUnitConnector";
- }
-
- SimpleEpisodicMemoryKinematicUnitConnector::SimpleEpisodicMemoryKinematicUnitConnector()
- {}
-
-
- void SimpleEpisodicMemoryKinematicUnitConnector::onInitComponent()
- {
-
- }
-
-
- void SimpleEpisodicMemoryKinematicUnitConnector::onConnectComponent()
- {
-
- }
-
-
- void SimpleEpisodicMemoryKinematicUnitConnector::onDisconnectComponent()
- {
-
- }
-
-
- void SimpleEpisodicMemoryKinematicUnitConnector::onExitComponent()
- {
-
- }
-
-
-
-
- armarx::PropertyDefinitionsPtr SimpleEpisodicMemoryKinematicUnitConnector::createPropertyDefinitions()
- {
- //armarx::PropertyDefinitionsPtr defs = new SimpleEpisodicMemoryKinematicUnitConnectorPropertyDefinitions(getConfigIdentifier());
- return nullptr;
- }
-}
diff --git a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.h b/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.h
deleted file mode 100644
index 7d9896ffaf1f7578de86d25d64e75c66af2f0297..0000000000000000000000000000000000000000
--- a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @package RobotAPI::ArmarXObjects::SimpleEpisodicMemoryKinematicUnitConnector
- * @author Fabian PK ( fabian dot peller-konrad at kit dot edu )
- * @date 2020
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-
-#include <ArmarXCore/core/Component.h>
-#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
-#include <MemoryX/components/SimpleEpisodicMemory/SimpleEpisodicMemoryConnector.h>
-
-
-namespace armarx
-{
-
- class SimpleEpisodicMemoryKinematicUnitConnector :
- public memoryx::SimpleEpisodicMemoryConnector,
- virtual public armarx::Component
-
- {
- public:
-
- /// @see armarx::ManagedIceObject::getDefaultName()
- std::string getDefaultName() const override;
-
- SimpleEpisodicMemoryKinematicUnitConnector();
-
- protected:
- void onInitComponent() override;
- void onConnectComponent() override;
- void onDisconnectComponent() override;
- void onExitComponent() override;
-
- armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
-
-
- private:
-
-
- };
-}
diff --git a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/CMakeLists.txt b/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/CMakeLists.txt
deleted file mode 100644
index 39691a0810ed53203efe1749605d57736fadb8a3..0000000000000000000000000000000000000000
--- a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-
-# Libs required for the tests
-SET(LIBS ${LIBS} ArmarXCore SimpleEpisodicMemoryKinematicUnitConnector)
-
-armarx_add_test(SimpleEpisodicMemoryKinematicUnitConnectorTest SimpleEpisodicMemoryKinematicUnitConnectorTest.cpp "${LIBS}")
diff --git a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/SimpleEpisodicMemoryKinematicUnitConnectorTest.cpp b/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/SimpleEpisodicMemoryKinematicUnitConnectorTest.cpp
deleted file mode 100644
index 46d89be8cac117abc4231a5e7b2cdfa5675f772a..0000000000000000000000000000000000000000
--- a/source/RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/test/SimpleEpisodicMemoryKinematicUnitConnectorTest.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @package RobotAPI::ArmarXObjects::SimpleEpisodicMemoryKinematicUnitConnector
- * @author Fabian PK ( fabian dot peller-konrad at kit dot edu )
- * @date 2020
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#define BOOST_TEST_MODULE RobotAPI::ArmarXObjects::SimpleEpisodicMemoryKinematicUnitConnector
-
-#define ARMARX_BOOST_TEST
-
-#include <RobotAPI/Test.h>
-#include <RobotAPI/components/SimpleEpisodicMemoryKinematicUnitConnector/SimpleEpisodicMemoryKinematicUnitConnector.h>
-
-#include <iostream>
-
-BOOST_AUTO_TEST_CASE(testExample)
-{
- armarx::SimpleEpisodicMemoryKinematicUnitConnector instance;
-
- BOOST_CHECK_EQUAL(true, true);
-}
diff --git a/source/RobotAPI/components/armem/CMakeLists.txt b/source/RobotAPI/components/armem/CMakeLists.txt
index 526448e132f6e282b3d3f14fd39132fe32017ebb..f6c875f0b9f96079cad2880ca2b64f48fc68fdb9 100644
--- a/source/RobotAPI/components/armem/CMakeLists.txt
+++ b/source/RobotAPI/components/armem/CMakeLists.txt
@@ -2,7 +2,7 @@
add_subdirectory(server)
# memory server addons
-
+add_subdirectory(addon)
# clients
add_subdirectory(client)
diff --git a/source/RobotAPI/components/armem/addon/CMakeLists.txt b/source/RobotAPI/components/armem/addon/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4328b4c0bc907ef6dc47d6bffdb816434d2ca7d6
--- /dev/null
+++ b/source/RobotAPI/components/armem/addon/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(LegacyRobotStateMemoryAdapter)
diff --git a/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/CMakeLists.txt b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9340296c089e80e1be44039534555519936551ba
--- /dev/null
+++ b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/CMakeLists.txt
@@ -0,0 +1,18 @@
+armarx_component_set_name("LegacyRobotStateMemoryAdapter")
+
+
+armarx_add_component(
+ SOURCES
+ ./LegacyRobotStateMemoryAdapter.cpp
+ HEADERS
+ ./LegacyRobotStateMemoryAdapter.h
+ LIBS
+ ArmarXCore ArmarXCoreInterfaces # for DebugObserverInterface
+ ArmarXGuiComponentPlugins
+ RobotAPICore RobotAPIInterfaces armem armem_robot_state
+)
+
+#generate the application
+armarx_generate_and_add_component_executable(
+ COMPONENT_NAMESPACE "armarx::armem"
+)
diff --git a/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.cpp b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b63913fdc88671f583339c7850134e23d8c5fbef
--- /dev/null
+++ b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.cpp
@@ -0,0 +1,290 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package RobotAPI::ArmarXObjects::MemoryNameSystem
+ * @author Rainer Kartmann ( rainer dot kartmann at kit dot edu )
+ * @date 2020
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "LegacyRobotStateMemoryAdapter.h"
+
+// ArmarX
+#include <RobotAPI/libraries/armem_robot_state/aron/Proprioception.aron.generated.h>
+#include <RobotAPI/libraries/armem_robot_state/aron/Transform.aron.generated.h>
+
+namespace armarx::armem
+{
+
+ armarx::PropertyDefinitionsPtr LegacyRobotStateMemoryAdapter::createPropertyDefinitions()
+ {
+ armarx::PropertyDefinitionsPtr defs = new ComponentPropertyDefinitions(getConfigIdentifier());
+
+ std::string prefix = "mem.";
+ defs->optional(properties.frequency, prefix + "updateFrequency", "The frequency in Hz to check for updates and send them to the memory.");
+ defs->optional(properties.memoryNameSystemName, prefix + "memoryNameSystemName", "The name of the MemoryNameSystem.");
+ defs->optional(properties.robotStateMemoryName, prefix + "memoryName", "The name of the RobotStateMemory.");
+
+ prefix = "listener.";
+ defs->topic<KinematicUnitListener>("RealRobotState", prefix + "KinematicUnitName");
+ defs->topic<PlatformUnitListener>("Armar6PlatformUnit", prefix + "PlatformUnitName");
+ return defs;
+ }
+
+
+ std::string LegacyRobotStateMemoryAdapter::getDefaultName() const
+ {
+ return "LegacyRobotStateMemoryAdapter";
+ }
+
+ void LegacyRobotStateMemoryAdapter::checkUpdateAndSendToMemory()
+ {
+ std::lock_guard l(updateMutex);
+ if (updateChanged)
+ {
+ // if the update is not changed it has probably been committed already
+ ARMARX_WARNING << deactivateSpam() << "Try to send data to robotStateMemory but data has not changed.";
+ return;
+ }
+
+ // convert the update into a commit and send to memory
+ arondto::Proprioception prop;
+ for (const auto& [k, v] : update.jointAngles)
+ {
+ prop.joints.position[k] = v;
+ }
+ for (const auto& [k, v] : update.jointAccelerations)
+ {
+ prop.joints.acceleration[k] = v;
+ }
+ for (const auto& [k, v] : update.jointCurrents)
+ {
+ prop.joints.motorCurrent[k] = v;
+ }
+ for (const auto& [k, v] : update.jointTorques)
+ {
+ prop.joints.torque[k] = v;
+ }
+ for (const auto& [k, v] : update.jointVelocities)
+ {
+ prop.joints.velocity[k] = v;
+ }
+
+ // is this corect??
+ prop.platform.acceleration = Eigen::Vector3f();
+ prop.platform.relativePosition = Eigen::Vector3f(update.platformPose.x,
+ update.platformPose.y,
+ update.platformPose.rotationAroundZ);
+ prop.platform.velocity = Eigen::Vector3f(std::get<0>(update.platformVelocity),
+ std::get<1>(update.platformVelocity),
+ std::get<2>(update.platformVelocity));
+
+ armem::EntityUpdate entityUpdate;
+ entityUpdate.entityID = propEntityID;
+ entityUpdate.timeCreated = IceUtil::Time::microSeconds(_timestampUpdateFirstModifiedInUs); // we take the oldest timestamp
+
+ entityUpdate.instancesData =
+ {
+ prop.toAron()
+ };
+
+ ARMARX_DEBUG << "Committing " << entityUpdate;
+ armem::EntityUpdateResult updateResult = memoryWriter.commit(entityUpdate);
+ ARMARX_INFO << updateResult;
+ if (!updateResult.success)
+ {
+ ARMARX_ERROR << updateResult.errorMessage;
+ }
+
+ // store odometry pose in localization segment
+ {
+ armem::arondto::Transform transform;
+ transform.header.agent = "Armar3";
+ transform.header.parentFrame = "Odom";
+ transform.header.frame = "root";
+ transform.header.timestamp = IceUtil::Time::microSeconds(_timestampUpdateFirstModifiedInUs);
+
+ Eigen::Isometry3f tf = Eigen::Isometry3f::Identity();
+ tf.translation().x() = std::get<0>(update.platformOdometryPose);
+ tf.translation().y() = std::get<1>(update.platformOdometryPose);
+ tf.linear() = Eigen::AngleAxisf(std::get<2>(update.platformOdometryPose), Eigen::Vector3f::UnitZ()).toRotationMatrix();
+
+ transform.transform = tf.matrix();
+
+ armem::EntityUpdate locUpdate;
+ locUpdate.entityID = locEntityID;
+ locUpdate.timeCreated = IceUtil::Time::microSeconds(_timestampUpdateFirstModifiedInUs);
+ locUpdate.instancesData =
+ {
+ transform.toAron()
+ };
+
+ ARMARX_DEBUG << "Committing " << entityUpdate;
+ armem::EntityUpdateResult updateResult = memoryWriter.commit(locUpdate);
+ ARMARX_INFO << updateResult;
+ if (!updateResult.success)
+ {
+ ARMARX_ERROR << updateResult.errorMessage;
+ }
+ }
+
+
+ // reset update
+ updateChanged = true;
+ }
+
+ void LegacyRobotStateMemoryAdapter::updateTimestamps(long ts)
+ {
+ if (updateChanged)
+ {
+ _timestampUpdateFirstModifiedInUs = IceUtil::Time::now().toMicroSeconds();
+ }
+ updateChanged = false;
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportControlModeChanged(const NameControlModeMap&, Ice::Long, bool, const Ice::Current&)
+ {
+
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointAngles(const NameValueMap& m, Ice::Long ts, bool, const Ice::Current&)
+ {
+ ARMARX_DEBUG << "Got an update for joint angles";
+ std::lock_guard l(updateMutex);
+ update.jointAngles = m;
+ updateTimestamps(ts);
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointVelocities(const NameValueMap& m, Ice::Long ts, bool, const Ice::Current&)
+ {
+ ARMARX_DEBUG << "Got an update for joint vels";
+ std::lock_guard l(updateMutex);
+ update.jointAngles = m;
+ updateTimestamps(ts);
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointTorques(const NameValueMap& m, Ice::Long ts, bool, const Ice::Current&)
+ {
+ ARMARX_DEBUG << "Got an update for joint torques";
+ std::lock_guard l(updateMutex);
+ update.jointAngles = m;
+ updateTimestamps(ts);
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointAccelerations(const NameValueMap& m, Ice::Long ts, bool, const Ice::Current&)
+ {
+ ARMARX_DEBUG << "Got an update for joint accels";
+ std::lock_guard l(updateMutex);
+ update.jointAngles = m;
+ updateTimestamps(ts);
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointCurrents(const NameValueMap& m, Ice::Long ts, bool, const Ice::Current&)
+ {
+ ARMARX_DEBUG << "Got an update for joint currents";
+ std::lock_guard l(updateMutex);
+ update.jointAngles = m;
+ updateTimestamps(ts);
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointMotorTemperatures(const NameValueMap&, Ice::Long, bool, const Ice::Current&)
+ {
+
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportJointStatuses(const NameStatusMap&, Ice::Long, bool, const Ice::Current&)
+ {
+
+ }
+
+ void LegacyRobotStateMemoryAdapter::reportPlatformPose(const PlatformPose& p, const Ice::Current &)
+ {
+ ARMARX_DEBUG << "Got an update for platform pose";
+ std::lock_guard l(updateMutex);
+ update.platformPose = p;
+ updateTimestamps(p.timestampInMicroSeconds);
+ }
+ void LegacyRobotStateMemoryAdapter::reportNewTargetPose(Ice::Float, Ice::Float, Ice::Float, const Ice::Current &)
+ {
+
+ }
+ void LegacyRobotStateMemoryAdapter::reportPlatformVelocity(Ice::Float f1, Ice::Float f2, Ice::Float f3, const Ice::Current &)
+ {
+ ARMARX_DEBUG << "Got an update for platform vels";
+ auto now = IceUtil::Time::now().toMicroSeconds();
+
+ std::lock_guard l(updateMutex);
+ update.platformVelocity = {f1, f2, f3};
+ updateTimestamps(now);
+ }
+ void LegacyRobotStateMemoryAdapter::reportPlatformOdometryPose(Ice::Float f1, Ice::Float f2, Ice::Float f3, const Ice::Current &)
+ {
+ ARMARX_DEBUG << "Got an update for platform odom pose";
+ auto now = IceUtil::Time::now().toMicroSeconds();
+
+ std::lock_guard l(updateMutex);
+ update.platformOdometryPose = {f1, f2, f3};
+ updateTimestamps(now);
+ }
+
+
+ void LegacyRobotStateMemoryAdapter::onInitComponent()
+ {
+ usingProxy(properties.memoryNameSystemName);
+
+ const int minFrequency = 1;
+ const int maxFrequency = 100;
+ properties.frequency = std::clamp(properties.frequency, minFrequency, maxFrequency);
+ const int fInMS = (1000 / properties.frequency);
+
+ // create running task and run method checkUpdateAndSendToMemory in a loop
+ runningTask = new PeriodicTask<LegacyRobotStateMemoryAdapter>(this, &LegacyRobotStateMemoryAdapter::checkUpdateAndSendToMemory, fInMS);
+ }
+
+
+ void LegacyRobotStateMemoryAdapter::onConnectComponent()
+ {
+ auto mns = client::MemoryNameSystem(getProxy<mns::MemoryNameSystemInterfacePrx>(properties.memoryNameSystemName), this);
+
+ // Wait for the memory to become available and add it as dependency.
+ ARMARX_IMPORTANT << "Waiting for memory '" << properties.robotStateMemoryName << "' ...";
+ propEntityID.memoryName = properties.robotStateMemoryName;
+ try
+ {
+ memoryWriter = mns.useWriter(properties.robotStateMemoryName);
+ }
+ catch (const armem::error::ArMemError& e)
+ {
+ ARMARX_ERROR << e.what();
+ return;
+ }
+
+ runningTask->start();
+ }
+
+
+ void LegacyRobotStateMemoryAdapter::onDisconnectComponent()
+ {
+ runningTask->stop();
+ }
+
+
+ void LegacyRobotStateMemoryAdapter::onExitComponent()
+ {
+ runningTask->stop();
+ }
+}
diff --git a/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.h b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..10f6c20ee094a657806ab21217b0bcba79758ad9
--- /dev/null
+++ b/source/RobotAPI/components/armem/addon/LegacyRobotStateMemoryAdapter/LegacyRobotStateMemoryAdapter.h
@@ -0,0 +1,125 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package RobotAPI::ArmarXObjects::MemoryNameSystem
+ * @author Rainer Kartmann ( rainer dot kartmann at kit dot edu )
+ * @date 2020
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <mutex>
+
+// Base Classes
+#include <ArmarXCore/core/Component.h>
+#include <RobotAPI/interface/armem/addon/LegacyRobotStateMemoryAdapterInterface.h>
+
+// ArmarX
+#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
+#include <RobotAPI/libraries/armem/client/Reader.h>
+#include <RobotAPI/libraries/armem/client/Writer.h>
+#include <RobotAPI/interface/armem/mns/MemoryNameSystemInterface.h>
+#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
+
+
+namespace armarx::armem
+{
+ class LegacyRobotStateMemoryAdapter :
+ virtual public armarx::Component,
+ virtual public robot_state::LegacyRobotStateMemoryAdapterInterface
+ {
+ public:
+
+ /// @see armarx::ManagedIceObject::getDefaultName()
+ std::string getDefaultName() const override;
+
+ void reportControlModeChanged(const NameControlModeMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointAngles(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointVelocities(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointTorques(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointAccelerations(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointCurrents(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointMotorTemperatures(const NameValueMap&, Ice::Long, bool, const Ice::Current&) override;
+ void reportJointStatuses(const NameStatusMap&, Ice::Long, bool, const Ice::Current&) override;
+
+ void reportPlatformPose(const PlatformPose &, const Ice::Current &) override;
+ void reportNewTargetPose(Ice::Float, Ice::Float, Ice::Float, const Ice::Current &) override;
+ void reportPlatformVelocity(Ice::Float, Ice::Float, Ice::Float, const Ice::Current &) override;
+ void reportPlatformOdometryPose(Ice::Float, Ice::Float, Ice::Float, const Ice::Current &) override;
+
+ protected:
+
+ /// @see PropertyUser::createPropertyDefinitions()
+ armarx::PropertyDefinitionsPtr createPropertyDefinitions() override;
+
+ /// @see armarx::ManagedIceObject::onInitComponent()
+ void onInitComponent() override;
+
+ /// @see armarx::ManagedIceObject::onConnectComponent()
+ void onConnectComponent() override;
+
+ /// @see armarx::ManagedIceObject::onDisconnectComponent()
+ void onDisconnectComponent() override;
+
+ /// @see armarx::ManagedIceObject::onExitComponent()
+ void onExitComponent() override;
+
+ private:
+ void updateTimestamps(long dataGeneratedUs);
+ void checkUpdateAndSendToMemory();
+
+ private:
+ // Update to send to the memory
+ struct Update
+ {
+ std::map<std::string, float> jointAngles = {};
+ std::map<std::string, float> jointVelocities = {};
+ std::map<std::string, float> jointTorques = {};
+ std::map<std::string, float> jointAccelerations = {};
+ std::map<std::string, float> jointCurrents = {};
+ armarx::PlatformPose platformPose = {};
+ std::tuple<float, float, float> platformVelocity = {0, 0, 0};
+ std::tuple<float, float, float> platformOdometryPose = {0, 0, 0};
+ };
+
+ // Update
+ bool updateChanged = true;
+ double _timestampUpdateFirstModifiedInUs;
+ Update update;
+
+ // Component properties
+ struct Properties
+ {
+ std::string memoryNameSystemName = "MemoryNameSystem";
+ std::string robotStateMemoryName = "RobotState";
+ int frequency = 100;
+ };
+ Properties properties;
+
+ // RunningTask
+ armarx::PeriodicTask<LegacyRobotStateMemoryAdapter>::pointer_type runningTask;
+
+ // Memory
+ MemoryID propEntityID = MemoryID("RobotState", "Proprioception", "Armar3", "Armar3");
+ MemoryID locEntityID = MemoryID("RobotState", "Localization", "Armar3", "Odom,root");
+
+ armem::client::Writer memoryWriter;
+
+ mutable std::mutex updateMutex;
+ };
+}
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/CMakeLists.txt b/source/RobotAPI/components/armem/client/ExampleMemoryClient/CMakeLists.txt
index 96cb0013af5534281083ba693c20ff83770f6155..667e5d5ad070e08f331d505fa4e742ce61b39df7 100644
--- a/source/RobotAPI/components/armem/client/ExampleMemoryClient/CMakeLists.txt
+++ b/source/RobotAPI/components/armem/client/ExampleMemoryClient/CMakeLists.txt
@@ -1,8 +1,5 @@
armarx_component_set_name("ExampleMemoryClient")
-find_package(IVT QUIET)
-armarx_build_if(IVT_FOUND "IVT not available")
-
find_package(OpenCV QUIET)
armarx_build_if(OpenCV_FOUND "OpenCV not available")
@@ -10,10 +7,9 @@ armarx_build_if(OpenCV_FOUND "OpenCV not available")
set(COMPONENT_LIBS
ArmarXCore ArmarXCoreInterfaces # for DebugObserverInterface
ArmarXGuiComponentPlugins
- RobotAPICore RobotAPIInterfaces armem
+ RobotAPICore RobotAPIInterfaces armem aronopencvconverter aronjsonconverter
- ${IVT_LIBRARIES}
- ${OpenCV_LIBS}
+ ${OpenCV_LIBRARIES}
)
set(SOURCES
@@ -25,8 +21,9 @@ set(HEADERS
)
armarx_add_component("${SOURCES}" "${HEADERS}")
-if (IVT_FOUND)
- target_include_directories(${ARMARX_COMPONENT_NAME} PUBLIC ${IVT_INCLUDE_DIRS})
+
+if(OpenCV_FOUND)
+ target_include_directories(${ARMARX_COMPONENT_NAME} SYSTEM PUBLIC ${OpenCV_INCLUDE_DIRS})
endif()
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.cpp b/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.cpp
index d8b6e4f89038a42fc137a78316cfa3fbd7bc7eb0..eae52c5054369e599acebfa5378075b7a448d6e5 100644
--- a/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.cpp
+++ b/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.cpp
@@ -24,6 +24,17 @@
#include <RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.aron.generated.h>
+#include <random>
+#include <algorithm>
+
+#include <opencv2/opencv.hpp>
+
+#include <SimoxUtility/color/cmaps.h>
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+#include <ArmarXCore/core/time/CycleUtil.h>
+
+
#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
#include <RobotAPI/libraries/armem/server/MemoryRemoteGui.h>
#include <RobotAPI/libraries/armem/client/query/Builder.h>
@@ -33,6 +44,8 @@
#include <RobotAPI/libraries/armem/core/operations.h>
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/time/CycleUtil.h>
@@ -43,14 +56,11 @@
#include <random>
-
-#define STORE_IMAGES 0
-
-#if STORE_IMAGES
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
-#endif
+#include <RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h>
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
namespace armarx
{
@@ -62,7 +72,7 @@ namespace armarx
defs->topic(debugObserver);
defs->optional(p.usedMemoryName, "mem.UsedMemoryName", "Name of the memory to use.");
- defs->optional(p.commitFrequency, "ex.CommitFrequency", "Frequency in which example data is commited.");
+ defs->optional(p.commitFrequency, "ex.CommitFrequency", "Frequency in which example data is commited. (max = 50Hz)");
return defs;
}
@@ -81,6 +91,8 @@ namespace armarx
void ExampleMemoryClient::onConnectComponent()
{
+ p.commitFrequency = std::min(p.commitFrequency, 50.f);
+
createRemoteGuiTab();
RemoteGui_startRunningTask();
@@ -158,16 +170,15 @@ namespace armarx
{
commitExamplesWithLinks();
}
+ if (true)
+ {
+ //commitExampleImages();
+ }
CycleUtil c(static_cast<int>(1000 / p.commitFrequency));
- int i = 0;
while (!task->isStopped())
{
- commitExampleData();
- if (i++ < 10000)
- {
- commitSingleSnapshot(exampleEntityID);
- }
+ commitSingleSnapshot(exampleEntityID);
c.waitForCycleDuration();
}
}
@@ -199,15 +210,15 @@ namespace armarx
double diff = (update.timeCreated - run_started).toMilliSecondsDouble() / 1000;
- auto dict1 = std::make_shared<aron::datanavigator::DictNavigator>();
- auto dict2 = std::make_shared<aron::datanavigator::DictNavigator>();
+ auto dict1 = std::make_shared<aron::data::Dict>();
+ auto dict2 = std::make_shared<aron::data::Dict>();
- auto sin = std::make_shared<aron::datanavigator::FloatNavigator>(std::sin(diff));
- auto cos = std::make_shared<aron::datanavigator::FloatNavigator>(std::cos(diff));
+ auto sin = std::make_shared<aron::data::Float>(std::sin(diff));
+ auto cos = std::make_shared<aron::data::Float>(std::cos(diff));
- auto sqrt = std::make_shared<aron::datanavigator::DoubleNavigator>(std::sqrt(diff));
- auto lin = std::make_shared<aron::datanavigator::LongNavigator>(static_cast<long>(diff * 1000));
- auto rand = std::make_shared<aron::datanavigator::IntNavigator>(distrib(gen));
+ auto sqrt = std::make_shared<aron::data::Double>(std::sqrt(diff));
+ auto lin = std::make_shared<aron::data::Long>(static_cast<long>(diff * 1000));
+ auto rand = std::make_shared<aron::data::Int>(distrib(gen));
dict1->addElement("sin", sin);
dict1->addElement("cos", cos);
@@ -245,7 +256,7 @@ namespace armarx
update.timeCreated = armem::Time::now() + armem::Time::seconds(i);
for (int j = 0; j < i; ++j)
{
- update.instancesData.push_back(std::make_shared<aron::datanavigator::DictNavigator>());
+ update.instancesData.push_back(std::make_shared<aron::data::Dict>());
}
}
ARMARX_IMPORTANT << "Committing " << commit;
@@ -352,7 +363,7 @@ namespace armarx
const armem::Time time = armem::Time::now();
armem::Commit commit;
- //default
+ //commit to default
{
armem::EntityUpdate& update = commit.add();
update.entityID = exampleDataProviderID.withEntityName("default");
@@ -360,9 +371,12 @@ namespace armarx
armem::example::ExampleData data;
toAron(data.memoryLink, armem::MemoryID());
+ ARMARX_CHECK_NOT_NULL(data.toAron());
update.instancesData = { data.toAron() };
}
- //the answer
+
+
+ //commit to the answer
{
armem::EntityUpdate& update = commit.add();
update.entityID = exampleDataProviderID.withEntityName("the answer");
@@ -400,7 +414,7 @@ namespace armarx
data.the_3x1_vector = { 24, 42, 2442 };
data.the_4x4_matrix = 42 * Eigen::Matrix4f::Identity();
- toAron(data.memoryLink, armem::MemoryID());
+ toAron(data.memoryLink, armem::MemoryID()); // ////1/1
simox::ColorMap cmap = simox::color::cmaps::plasma();
{
@@ -416,11 +430,9 @@ namespace armarx
pixel.z = color.b;
});
-#if STORE_IMAGES
- cv::Mat out;
- cv::cvtColor(image, out, CV_RGB2BGR);
- cv::imwrite("the_rgb24_image.png", out);
-#endif
+ //cv::Mat out;
+ //cv::cvtColor(image, out, /*CV_RGB2BGR*/);
+ cv::imwrite("/tmp/the_rgb24_image.png", image); // out
}
{
cv::Mat& image = data.the_depth32_image;
@@ -430,7 +442,6 @@ namespace armarx
pixel = 100 * float(index[0] + index[1]) / float(image.rows + image.cols);
});
-#if STORE_IMAGES
cmap.set_vlimits(0, 100);
cv::Mat rgb(image.rows, image.cols, CV_8UC3);
using Pixel = cv::Point3_<uint8_t>;
@@ -442,12 +453,12 @@ namespace armarx
pixel.z = color.b;
});
- cv::Mat out;
- cv::cvtColor(rgb, out, CV_RGB2BGR);
- cv::imwrite("the_depth32_image.png", out);
-#endif
+ //cv::Mat out;
+ //cv::cvtColor(rgb, out, CV_RGB2BGR);
+ cv::imwrite("/tmp/the_depth32_image.png", image); // out
}
+ ARMARX_CHECK_NOT_NULL(data.toAron());
update.instancesData = { data.toAron() };
}
@@ -542,6 +553,28 @@ namespace armarx
}
}
+ void ExampleMemoryClient::commitExampleImages()
+ {
+ const armem::Time time = armem::Time::now();
+
+ armem::Commit commit;
+ {
+ armem::EntityUpdate& update = commit.add();
+ update.entityID = exampleDataProviderID.withEntityName("some_new_fancy_entity_id");
+ update.timeCreated = time;
+
+ auto currentFolder = std::filesystem::current_path();
+ auto opencv_img = cv::imread((currentFolder / "images" / (std::to_string(imageCounter + 1) + ".jpg")).string());
+ imageCounter++;
+ imageCounter %= 10;
+
+ auto data = std::make_shared<aron::data::Dict>();
+ data->addElement("opencv_image", aron::converter::AronOpenCVConverter::ConvertFromMat(opencv_img));
+
+ update.instancesData = { data };
+ }
+ }
+
void ExampleMemoryClient::processExampleEntityUpdate(
const armem::MemoryID& subscriptionID, const std::vector<armem::MemoryID>& snapshotIDs)
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.h b/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.h
index 40eb57625848ba442e7be2abb10ed1c832ee8440..0adda091a10f7c07585fe1a34d00ee3d7cae0737 100644
--- a/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.h
+++ b/source/RobotAPI/components/armem/client/ExampleMemoryClient/ExampleMemoryClient.h
@@ -100,6 +100,8 @@ namespace armarx
void commitExamplesWithLinks();
+ void commitExampleImages();
+
private:
@@ -121,6 +123,7 @@ namespace armarx
IceUtil::Time run_started;
+ unsigned int imageCounter = 0;
armarx::RunningTask<ExampleMemoryClient>::pointer_type task;
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/1.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0320f72804f0ca35c42ca4713044d840a4ce56d2
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/1.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/10.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/10.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..88489ef2e3a6bc4718c2f0b0e3dc7b9831d281e6
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/10.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/2.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..af1bda2bdbf18a2441fc8da27d84013a0d0caee1
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/2.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/3.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d972613dd712d9ece74a4e3868715ce8228b9c18
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/3.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/4.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/4.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bf2552bfa02cb09bee4ddc05e376d73ca70979aa
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/4.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/5.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/5.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..484f23917a1348c6e07e2c9b967b500648474606
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/5.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/6.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/6.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6dfeeb74aa4b9da9f8a6c864de0bc41a13e88625
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/6.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/7.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/7.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..487fff16ed4e482a3e0e6ba523f0384977f87e5b
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/7.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/8.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/8.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2e291333388940ab1dc3189ed6d17f3102b08e56
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/8.jpg differ
diff --git a/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/9.jpg b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/9.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..407f37579c74589c70e64f4fb9d3c7c8b7e13e7c
Binary files /dev/null and b/source/RobotAPI/components/armem/client/ExampleMemoryClient/images/9.jpg differ
diff --git a/source/RobotAPI/components/armem/server/ExampleMemory/CMakeLists.txt b/source/RobotAPI/components/armem/server/ExampleMemory/CMakeLists.txt
index cc053e479e74106b7a682d6c2c40549eb486f5d0..de9b660b2175a34c4cd3aeb90152370f222ceb11 100644
--- a/source/RobotAPI/components/armem/server/ExampleMemory/CMakeLists.txt
+++ b/source/RobotAPI/components/armem/server/ExampleMemory/CMakeLists.txt
@@ -1,15 +1,12 @@
armarx_component_set_name("ExampleMemory")
-find_package(IVT QUIET)
-armarx_build_if(IVT_FOUND "IVT not available")
-
+find_package(OpenCV QUIET)
+armarx_build_if(OpenCV_FOUND "OpenCV not available")
set(COMPONENT_LIBS
ArmarXCore ArmarXCoreInterfaces # for DebugObserverInterface
ArmarXGuiComponentPlugins
RobotAPICore RobotAPIInterfaces armem
-
- ${IVT_LIBRARIES}
)
set(SOURCES
@@ -19,12 +16,11 @@ set(HEADERS
ExampleMemory.h
)
-
armarx_add_component("${SOURCES}" "${HEADERS}")
-if (IVT_FOUND)
- target_include_directories(${ARMARX_COMPONENT_NAME} PUBLIC ${IVT_INCLUDE_DIRS})
-endif()
+if (OpenCV_FOUND)
+ target_include_directories(${ARMARX_COMPONENT_NAME} PUBLIC ${OpenCV_INCLUDE_DIRS})
+endif()
armarx_enable_aron_file_generation_for_target(
TARGET_NAME
diff --git a/source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.cpp b/source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.cpp
index 446c0e2294ba03c7b9042d98416fc5a27f1513a7..cb2ba76bf3a1a2bf3f739c52692ef5ebf0f8cb4a 100644
--- a/source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.cpp
+++ b/source/RobotAPI/components/armem/server/ExampleMemory/ExampleMemory.cpp
@@ -40,7 +40,7 @@ namespace armarx
defs->topic(debugObserver);
- workingMemory().name() = "Example";
+ setMemoryName("Example");
p.core._defaultSegmentsStr = simox::alg::join(p.core.defaultCoreSegments, ", ");
defs->optional(p.core._defaultSegmentsStr, "core.DefaultSegments",
diff --git a/source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml b/source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml
index 6347fef0adf48e84d1104985481b05732db7b11f..be9a9788fae8045e98d211d6a2b7397d6da455eb 100644
--- a/source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml
+++ b/source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml
@@ -17,98 +17,100 @@ An example data containing different native ARON types.
</AronIncludes>
<GenerateTypes>
+ <Object name='armarx::armem::example::InnerClass'>
+ <ObjectChild key='element_int'>
+ <Int />
+ </ObjectChild>
+ <ObjectChild key='element_float'>
+ <Float />
+ </ObjectChild>
+ <ObjectChild key='element_string'>
+ <String />
+ </ObjectChild>
+ </Object>
+
<Object name='armarx::armem::example::ExampleData'>
- <ObjectChild key='the_int'>
- <Int />
- </ObjectChild>
- <ObjectChild key='the_long'>
- <Long />
- </ObjectChild>
- <ObjectChild key='the_float'>
- <Float />
- </ObjectChild>
- <ObjectChild key='the_double'>
- <Double />
- </ObjectChild>
- <ObjectChild key='the_string'>
- <String />
- </ObjectChild>
- <ObjectChild key='the_bool'>
- <Bool />
- </ObjectChild>
+ <ObjectChild key='the_int'>
+ <Int />
+ </ObjectChild>
+ <ObjectChild key='the_long'>
+ <Long />
+ </ObjectChild>
+ <ObjectChild key='the_float'>
+ <Float />
+ </ObjectChild>
+ <ObjectChild key='the_double'>
+ <Double />
+ </ObjectChild>
+ <ObjectChild key='the_string'>
+ <String />
+ </ObjectChild>
+ <ObjectChild key='the_bool'>
+ <Bool />
+ </ObjectChild>
- <ObjectChild key='the_position'>
- <Position />
- </ObjectChild>
- <ObjectChild key='the_orientation'>
- <Orientation />
- </ObjectChild>
- <ObjectChild key='the_pose'>
- <Pose />
- </ObjectChild>
+ <ObjectChild key='the_position'>
+ <Position />
+ </ObjectChild>
+ <ObjectChild key='the_orientation'>
+ <Orientation />
+ </ObjectChild>
+ <ObjectChild key='the_pose'>
+ <Pose />
+ </ObjectChild>
- <ObjectChild key='the_3x1_vector'>
- <EigenMatrix rows="3" cols="1" type="float" />
- </ObjectChild>
- <ObjectChild key='the_4x4_matrix'>
- <EigenMatrix rows="4" cols="4" type="float" />
- </ObjectChild>
- <ObjectChild key='the_rgb24_image'>
- <Image pixelType="rgb24"/>
- </ObjectChild>
- <ObjectChild key='the_depth32_image'>
- <Image pixelType="depth32"/>
- </ObjectChild>
+ <ObjectChild key='the_3x1_vector'>
+ <Matrix rows="3" cols="1" type="float32" />
+ </ObjectChild>
+ <ObjectChild key='the_4x4_matrix'>
+ <Matrix rows="4" cols="4" type="float32" />
+ </ObjectChild>
+ <ObjectChild key='the_rgb24_image'>
+ <Image type="rgb24"/>
+ </ObjectChild>
+ <ObjectChild key='the_depth32_image'>
+ <Image type="depth32"/>
+ </ObjectChild>
- <ObjectChild key='the_float_list'>
- <List>
- <Float />
- </List>
- </ObjectChild>
- <ObjectChild key='the_int_list'>
- <List>
- <Int />
- </List>
- </ObjectChild>
- <ObjectChild key='the_string_list'>
- <List>
- <String />
- </List>
- </ObjectChild>
+ <ObjectChild key='the_float_list'>
+ <List>
+ <Float />
+ </List>
+ </ObjectChild>
+ <ObjectChild key='the_int_list'>
+ <List>
+ <Int />
+ </List>
+ </ObjectChild>
+ <ObjectChild key='the_string_list'>
+ <List>
+ <String />
+ </List>
+ </ObjectChild>
- <ObjectChild key='the_object_list'>
- <List>
- <Object name='InnerClass'>
- <ObjectChild key='element_int'>
- <Int />
- </ObjectChild>
- <ObjectChild key='element_float'>
- <Float />
- </ObjectChild>
- <ObjectChild key='element_string'>
- <String />
- </ObjectChild>
- </Object>
- </List>
- </ObjectChild>
+ <ObjectChild key='the_object_list'>
+ <List>
+ <armarx::armem::example::InnerClass />
+ </List>
+ </ObjectChild>
- <ObjectChild key='the_float_dict'>
- <Dict>
- <Float />
- </Dict>
- </ObjectChild>
- <ObjectChild key='the_int_dict'>
- <Dict>
- <Int />
- </Dict>
- </ObjectChild>
+ <ObjectChild key='the_float_dict'>
+ <Dict>
+ <Float />
+ </Dict>
+ </ObjectChild>
+ <ObjectChild key='the_int_dict'>
+ <Dict>
+ <Int />
+ </Dict>
+ </ObjectChild>
- <ObjectChild key="memoryLink">
- <armarx::armem::arondto::MemoryID />
- </ObjectChild>
+ <ObjectChild key="memoryLink">
+ <armarx::armem::arondto::MemoryID />
+ </ObjectChild>
- </Object>
- </GenerateTypes>
+ </Object>
+ </GenerateTypes>
</AronTypeDefinition>
diff --git a/source/RobotAPI/components/armem/server/ExampleMemory/test/ExampleMemoryTest.cpp b/source/RobotAPI/components/armem/server/ExampleMemory/test/ExampleMemoryTest.cpp
index 56c9d08f49759de2f75c8085551ea63fb9263935..c3d2b817956435a450b1f3ae0a91ebc20044c314 100644
--- a/source/RobotAPI/components/armem/server/ExampleMemory/test/ExampleMemoryTest.cpp
+++ b/source/RobotAPI/components/armem/server/ExampleMemory/test/ExampleMemoryTest.cpp
@@ -39,7 +39,7 @@ namespace armem = armarx::armem;
BOOST_AUTO_TEST_CASE(test_ExampleData_type)
{
- armarx::aron::typenavigator::ObjectNavigatorPtr type = ExampleData::toAronType();
+ armarx::aron::type::ObjectPtr type = ExampleData::toAronType();
BOOST_CHECK_EQUAL(type->childrenSize(), 16);
diff --git a/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.cpp b/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.cpp
index c9eae54f7d33aeeab1afede2612eea3f0c2bf868..3901a510fdcb5bec61a2b18cc2e64b2cab0ecf64 100644
--- a/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.cpp
+++ b/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.cpp
@@ -45,11 +45,10 @@ namespace armarx::armem::server::robot_state
{
addPlugin(debugObserver);
ARMARX_CHECK_NOT_NULL(debugObserver);
+
addPlugin(robotUnit.plugin);
ARMARX_CHECK_NOT_NULL(robotUnit.plugin);
-
- robotUnit.reader.setTag(getName());
- robotUnit.writer.setTag(getName());
+ robotUnit.plugin->setRobotUnitAsOptionalDependency(true);
}
@@ -62,19 +61,19 @@ namespace armarx::armem::server::robot_state
{
armarx::PropertyDefinitionsPtr defs = new ComponentPropertyDefinitions(getConfigIdentifier());
- const std::string robotUnitPrefix = sensorValuePrefix;
+ const std::string robotUnitPrefix = robotUnit.sensorValuePrefix;
defs->optional(robotUnit.reader.properties.sensorPrefix, robotUnitPrefix + "SensorValuePrefix",
"Prefix of all sensor values.");
defs->optional(robotUnit.pollFrequency, robotUnitPrefix + "UpdateFrequency",
"The frequency to store values in Hz. All other values get discarded. "
- "Minimum is 1, max is " + std::to_string(ROBOT_UNIT_MAXIMUM_FREQUENCY) + ".")
- .setMin(1).setMax(ROBOT_UNIT_MAXIMUM_FREQUENCY);
+ "Minimum is 1, max is " + std::to_string(robotUnit.ROBOT_UNIT_MAXIMUM_FREQUENCY) + ".")
+ .setMin(1).setMax(robotUnit.ROBOT_UNIT_MAXIMUM_FREQUENCY);
const std::string prefix = "mem.";
- workingMemory().name() = "RobotState";
+ setMemoryName("RobotState");
descriptionSegment.defineProperties(defs, prefix + "desc.");
proprioceptionSegment.defineProperties(defs, prefix + "prop.");
@@ -98,7 +97,7 @@ namespace armarx::armem::server::robot_state
localizationSegment.onInit();
commonVisu.init();
- robotUnit.pollFrequency = std::clamp(robotUnit.pollFrequency, 0.f, ROBOT_UNIT_MAXIMUM_FREQUENCY);
+ robotUnit.pollFrequency = std::clamp(robotUnit.pollFrequency, 0.f, robotUnit.ROBOT_UNIT_MAXIMUM_FREQUENCY);
std::vector<std::string> includePaths;
std::vector<std::string> packages = armarx::Application::GetProjectDependencies();
@@ -123,38 +122,43 @@ namespace armarx::armem::server::robot_state
{
ARMARX_CHECK_NOT_NULL(debugObserver->getDebugObserver());
- if (robotUnit.plugin->getRobotUnit())
+ // 1. General setup
+ localizationSegment.onConnect();
+ commonVisu.connect(getArvizClient(), debugObserver->getDebugObserver());
+
+ // 2. Check for RobotUnit. If RobotUnit is enabled. Otherwise we do not wait for a streaming service and do not setup the segments
+ if (robotUnit.plugin->hasRobotUnitName())
{
robotUnit.plugin->waitUntilRobotUnitIsRunning();
- }
- RobotUnitInterfacePrx robotUnitPrx = robotUnit.plugin->getRobotUnit();
+ RobotUnitInterfacePrx robotUnitPrx = robotUnit.plugin->getRobotUnit();
- descriptionSegment.onConnect(robotUnitPrx);
- proprioceptionSegment.onConnect(robotUnitPrx);
- localizationSegment.onConnect();
+ robotUnit.reader.setTag(getName());
+ robotUnit.writer.setTag(getName());
- commonVisu.connect(getArvizClient(), debugObserver->getDebugObserver());
+ descriptionSegment.onConnect(robotUnitPrx);
+ proprioceptionSegment.onConnect(robotUnitPrx);
- robotUnit.reader.connect(*robotUnit.plugin, *debugObserver,
- proprioceptionSegment.getRobotUnitProviderID().providerSegmentName);
- robotUnit.writer.connect(*debugObserver);
- robotUnit.writer.properties.robotUnitProviderID = proprioceptionSegment.getRobotUnitProviderID();
+ robotUnit.reader.connect(*robotUnit.plugin, *debugObserver,
+ proprioceptionSegment.getRobotUnitProviderID().providerSegmentName);
+ robotUnit.writer.connect(*debugObserver);
+ robotUnit.writer.properties.robotUnitProviderID = proprioceptionSegment.getRobotUnitProviderID();
- robotUnit.reader.task = new SimpleRunningTask<>([this]()
- {
- robotUnit.reader.run(
- robotUnit.pollFrequency, robotUnit.dataQueue, robotUnit.dataMutex
- );
- }, "Robot Unit Reader");
- robotUnit.writer.task = new SimpleRunningTask<>([this]()
- {
- robotUnit.writer.run(
- robotUnit.pollFrequency, robotUnit.dataQueue, robotUnit.dataMutex,
- iceAdapter(), localizationSegment
- );
- }, "Robot State Writer");
+ robotUnit.reader.task = new SimpleRunningTask<>([this]()
+ {
+ robotUnit.reader.run(
+ robotUnit.pollFrequency, robotUnit.dataQueue, robotUnit.dataMutex
+ );
+ }, "Robot Unit Reader");
+ robotUnit.writer.task = new SimpleRunningTask<>([this]()
+ {
+ robotUnit.writer.run(
+ robotUnit.pollFrequency, robotUnit.dataQueue, robotUnit.dataMutex,
+ iceAdapter(), localizationSegment
+ );
+ }, "Robot State Writer");
- startRobotUnitStream();
+ startRobotUnitStream();
+ }
}
@@ -177,6 +181,8 @@ namespace armarx::armem::server::robot_state
void RobotStateMemory::startRobotUnitStream()
{
+ ARMARX_CHECK(robotUnit.plugin->robotUnitIsRunning());
+
if (robotUnit.reader.task->isRunning() || robotUnit.writer.task->isRunning())
{
if (robotUnit.reader.task->isRunning() && robotUnit.writer.task->isRunning())
diff --git a/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.h b/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.h
index 74dd4a3fa12fea08186ec14d1b93fdf6872ac7dd..6459b2aac44dbea0a64c8b2fe35efed2e69f020c 100644
--- a/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.h
+++ b/source/RobotAPI/components/armem/server/RobotStateMemory/RobotStateMemory.h
@@ -111,6 +111,10 @@ namespace armarx::armem::server::robot_state
struct RobotUnit
{
+ // params
+ static constexpr float ROBOT_UNIT_MAXIMUM_FREQUENCY = 100;
+ static constexpr const char* sensorValuePrefix = "RobotUnit.";
+
float pollFrequency = 50;
armarx::plugins::RobotUnitComponentPlugin* plugin = nullptr;
@@ -122,13 +126,6 @@ namespace armarx::armem::server::robot_state
std::mutex dataMutex;
};
RobotUnit robotUnit;
-
-
- // params
- static constexpr float ROBOT_UNIT_MAXIMUM_FREQUENCY = 100;
- static constexpr const char* sensorValuePrefix = "RobotUnit.";
-
-
};
} // namespace armarx::armem::server::robot_state
diff --git a/source/RobotAPI/interface/CMakeLists.txt b/source/RobotAPI/interface/CMakeLists.txt
index a7cc9ca79c5ecc5f99f294065709cc3daa0e2790..a4810afdc94dbd8b1260a3e5c41ba714d3c25d42 100644
--- a/source/RobotAPI/interface/CMakeLists.txt
+++ b/source/RobotAPI/interface/CMakeLists.txt
@@ -126,6 +126,9 @@ set(SLICE_FILES
# Special Servers
armem/server/ObjectMemoryInterface.ice
+ # Special Addons
+ armem/addon/LegacyRobotStateMemoryAdapterInterface.ice
+
armem/mns.ice
armem/mns/MemoryNameSystemInterface.ice
diff --git a/source/RobotAPI/interface/armem/addon/LegacyRobotStateMemoryAdapterInterface.ice b/source/RobotAPI/interface/armem/addon/LegacyRobotStateMemoryAdapterInterface.ice
new file mode 100644
index 0000000000000000000000000000000000000000..ffd72e20c51675c207869ae3c8c66e52b84c77fa
--- /dev/null
+++ b/source/RobotAPI/interface/armem/addon/LegacyRobotStateMemoryAdapterInterface.ice
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <RobotAPI/interface/units/KinematicUnitInterface.ice>
+#include <RobotAPI/interface/units/PlatformUnitInterface.ice>
+
+module armarx
+{
+ module armem
+ {
+ module robot_state
+ {
+ interface LegacyRobotStateMemoryAdapterInterface extends armarx::KinematicUnitListener, armarx::PlatformUnitListener
+ {
+ }
+ }
+ }
+}
diff --git a/source/RobotAPI/interface/armem/commit.ice b/source/RobotAPI/interface/armem/commit.ice
index 07bffd26316d405e8340f1ccbf1c35f46ad5adf7..526188ecf649745cb52e1fd00212d48c602cfcee 100644
--- a/source/RobotAPI/interface/armem/commit.ice
+++ b/source/RobotAPI/interface/armem/commit.ice
@@ -33,7 +33,7 @@ module armarx
struct EntityUpdate
{
armem::data::MemoryID entityID;
- aron::data::AronDictSeq instancesData;
+ aron::data::dto::AronDictSeq instancesData;
long timeCreatedMicroSeconds;
float confidence = 1.0;
diff --git a/source/RobotAPI/interface/armem/memory.ice b/source/RobotAPI/interface/armem/memory.ice
index bbf0059faf5329210ee086cf12756c098be73f1a..a4cdd0cde1de4f553fd4181f6515e1fd4255ae01 100644
--- a/source/RobotAPI/interface/armem/memory.ice
+++ b/source/RobotAPI/interface/armem/memory.ice
@@ -29,7 +29,7 @@ module armarx
};
class TypedMemoryContainer extends MemoryItem
{
- aron::type::AronType aronType;
+ aron::type::dto::GenericType aronType;
};
}
@@ -45,7 +45,7 @@ module armarx
/// Ice Twin of `armarx::armem::EntityInstance`.
class EntityInstance extends detail::MemoryItem
{
- aron::data::AronDict data;
+ aron::data::dto::Dict data;
EntityInstanceMetadata metadata;
};
diff --git a/source/RobotAPI/interface/aron/Aron.ice b/source/RobotAPI/interface/aron/Aron.ice
index 9c3baf7929680117c4b933960fa00342600ee06b..4eb7b587cb876c3f832744f02e45725196e5d47f 100644
--- a/source/RobotAPI/interface/aron/Aron.ice
+++ b/source/RobotAPI/interface/aron/Aron.ice
@@ -1,31 +1,7 @@
#pragma once
-// AronMacros (copied from Config.h)
-/************************************
- * TYPES ****************************
- ***********************************/
-#define HANDLE_PRIMITIVE_TYPES \
- RUN_ARON_MACRO(Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE) \
- RUN_ARON_MACRO(String, string, STRING) \
- RUN_ARON_MACRO(Bool, bool, BOOL) \
- RUN_ARON_MACRO(Time, time, TIME)
-
-/************************************
- * DATA *****************************
- ***********************************/
-#define HANDLE_PRIMITIVE_DATA \
- RUN_ARON_MACRO(Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE) \
- RUN_ARON_MACRO(String, string, STRING) \
- RUN_ARON_MACRO(Bool, bool, BOOL)
-
-#define ARON_VERSION "beta 0.2.2"
+#define ARON_VERSION "beta 0.2.3"
module armarx
{
@@ -37,9 +13,9 @@ module armarx
/*************************
* General Definitions ***
************************/
- sequence<byte> AronByteSequence;
- sequence<int> AronIntSequence;
- sequence<string> AronStringSequence;
+ sequence<byte> AronByteSeq;
+ sequence<int> AronIntSeq;
+ sequence<string> AronStringSeq;
dictionary<string, int> AronIntDict;
@@ -57,54 +33,103 @@ module armarx
eSharedPointer
};
- class AronType {
- //string VERSION = ARON_VERSION;
- Maybe maybe = Maybe::eNone; // Every type can have a maye type flag or not
- }
- sequence<AronType> AronTypeList;
- dictionary<string, AronType> AronTypeDict;
-
- // Container types
- class AronList extends AronType { AronType acceptedType; }
- class AronTuple extends AronType { AronTypeList elementTypes; }
- class AronPair extends AronType { AronType acceptedType1; AronType acceptedType2; }
- class AronObject extends AronType { AronObject parent; string objectName; AronTypeDict elementTypes; }
- class AronDict extends AronType { AronType acceptedType; }
-
- // Complex Types (serialize to ndarray)
-
-
- class AronNDArray extends AronType { AronIntSequence dimensions; int elementSize; string typeName; }
- // NdArray should look like this:
- // class AronNDArray extends AronType { int ndim; string type; }
- // type can be: "uint8", "int8", "uint16", "int16", "uint32", "int32", "float32", "float64"
-
-
-
- class AronEigenMatrix extends AronType { int rows; int cols; string typeName; }
- class AronEigenQuaternion extends AronType { string typeName; }
-
- // pixelType can be: "rgb24", "depth32"
- class AronImage extends AronType { string pixelType; }
+ module ndarray
+ {
+ enum ElementType
+ {
+ uint8,
+ int8,
+ uint16,
+ int16,
+ uint32,
+ int32,
+ float32,
+ float64
+ };
+ };
- // to be removed:
- class AronIVTCByteImage extends AronType { }
- class AronOpenCVMat extends AronType { AronIntSequence shape; string typeName; }
+ module image
+ {
+ enum PixelType
+ {
+ rgb24,
+ depth32
+ };
+ };
- class AronPCLPointCloud extends AronType { string typeName; }
- class AronPosition extends AronType { }
- class AronOrientation extends AronType { }
- class AronPose extends AronType { }
+ module pointcloud
+ {
+ enum VoxelType
+ {
+ PointXYZ,
+ PointXYZI,
+ PointXYZL,
+ PointXYZRGB,
+ PointXYZRGBL,
+ PointXYZRGBA,
+ PointXYZHSV
+ };
+ };
- // Enum types
- class AronIntEnum extends AronType { string enumName; AronIntDict acceptedValues; }
+ module matrix
+ {
+ enum ElementType
+ {
+ int16,
+ int32,
+ int64,
+ float32,
+ float64
+ };
+ };
- // Primitive Types
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class Aron##upperType extends AronType { };
+ module quaternion
+ {
+ enum ElementType
+ {
+ float32,
+ float64
+ };
+ };
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
+ module dto
+ {
+ class GenericType {
+ string VERSION = ARON_VERSION;
+ Maybe maybe = Maybe::eNone;
+ }
+ sequence<GenericType> GenericTypeSeq;
+ dictionary<string, GenericType> GenericTypeDict;
+
+ /* ***** Container types ***** */
+ class List extends GenericType { GenericType acceptedType; }
+ class Tuple extends GenericType { GenericTypeSeq elementTypes; }
+ class Pair extends GenericType { GenericType acceptedType1; GenericType acceptedType2; }
+ class AronObject extends GenericType { AronObject parent; string objectName; GenericTypeDict elementTypes; }
+ class Dict extends GenericType { GenericType acceptedType; }
+
+ /* ***** Complex Types (serialize to ndarray) ***** */
+ class NDArray extends GenericType { int ndimensions; ndarray::ElementType elementType; }
+ class Matrix extends GenericType { int rows; int cols; matrix::ElementType elementType; }
+ class Quaternion extends GenericType { quaternion::ElementType elementType; }
+ class Image extends GenericType { image::PixelType pixelType; }
+ class PointCloud extends GenericType { pointcloud::VoxelType voxelType; }
+ class Position extends GenericType { }
+ class Orientation extends GenericType { }
+ class Pose extends GenericType { }
+
+ /* ***** Enum types ***** */
+ class IntEnum extends GenericType { string enumName; AronIntDict acceptedValues; }
+
+ /* ***** Primitive Types ***** */
+ class AronInt extends GenericType { };
+ class AronLong extends GenericType { };
+ class AronDouble extends GenericType { };
+ class AronFloat extends GenericType { };
+ class AronString extends GenericType { };
+ class AronBool extends GenericType { };
+ class AronTime extends GenericType { };
+ };
};
@@ -113,38 +138,36 @@ module armarx
************************/
module data
{
- class AronData {
- //string VERSION = ARON_VERSION;
+ module dto
+ {
+ class GenericData {
+ string VERSION = ARON_VERSION;
+ };
+ sequence<GenericData> GenericDataSeq;
+ dictionary<string, GenericData> GenericDataDict;
+
+ /* ***** Container Data ***** */
+ class List extends GenericData { GenericDataSeq elements; };
+ class Dict extends GenericData { GenericDataDict elements; };
+
+ /* ***** Complex Data ***** */
+ // The NDArray contains more or less the same information as an AronType, but there is no other way to do it
+ // Especially, note the difference between the type's typeName (e.g. "GRAY_SCALE_IMAGE" => language dependent) and the data's type ("0")
+ // Further, note the difference between the type's dimensions (e.g. 128x128) and the data's dimensions (128x128x3 for RGB)
+ class NDArray extends GenericData { AronIntSeq shape; string type; AronByteSeq data; }
+
+
+ /* ***** Primitive Data ***** */
+ class AronInt extends GenericData { int value; };
+ class AronLong extends GenericData { long value; };
+ class AronDouble extends GenericData { double value; };
+ class AronFloat extends GenericData { float value; };
+ class AronString extends GenericData { string value; };
+ class AronBool extends GenericData { bool value; };
+
+ // useful for memory ice_conversions
+ sequence<Dict> AronDictSeq;
};
- sequence<AronData> AronDataList;
- dictionary<string, AronData> AronDataDict;
-
- // Container Data
- class AronList extends AronData { AronDataList elements; };
- class AronDict extends AronData { AronDataDict elements; };
-
- // Complex Data. The NDArray contains more or less the same information as an AronType, but there is no other way to do it
- // Especially, note the difference between the type's typeName (e.g. "GRAY_SCALE_IMAGE") and the data's type ("0")
- // Further, note the difference between the type's dimensions (e.g. 128x128) and the data's dimensions (128x128x3 for RGB)
- class AronNDArray extends AronData { AronIntSequence dimensions; string type; AronByteSequence data; };
-
- // NDArray should look like this: (type is be as above and implies the bit-width of an element)
- // class AronNDArray extends AronData { AronIntSequence shape; string type; AronByteSequence data; };
-
-
- // Primitive Data
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class Aron##upperType extends AronData { lowerType value; };
-
- HANDLE_PRIMITIVE_DATA
- #undef RUN_ARON_MACRO
-
- // useful for memory ice_conversions
- sequence<AronDict> AronDictSeq;
};
-
};
};
-
-#undef HANDLE_PRIMITIVE_DATA
-#undef HANDLE_PRIMITIVE_TYPES
diff --git a/source/RobotAPI/interface/components/NaturalIKInterface.ice b/source/RobotAPI/interface/components/NaturalIKInterface.ice
index dfec180ff3be0ff09d9722e5ea029c53d1a9657a..40a8d2fc22ccf48e92d9d43f056413d42d50ea03 100644
--- a/source/RobotAPI/interface/components/NaturalIKInterface.ice
+++ b/source/RobotAPI/interface/components/NaturalIKInterface.ice
@@ -36,6 +36,6 @@ module armarx
interface NaturalIKInterface
{
- NaturalIKResult solveIK(string side, Eigen::Matrix4f target, bool setOrientation, aron::data::AronDict args);
+ NaturalIKResult solveIK(string side, Eigen::Matrix4f target, bool setOrientation, aron::data::dto::Dict args);
};
};
diff --git a/source/RobotAPI/interface/skills/SkillProviderInterface.ice b/source/RobotAPI/interface/skills/SkillProviderInterface.ice
index 11accead03c2f5e8d83e627017ccbcd6e4fa7b21..8ed73e307433859389035e4aa99284994860c37e 100644
--- a/source/RobotAPI/interface/skills/SkillProviderInterface.ice
+++ b/source/RobotAPI/interface/skills/SkillProviderInterface.ice
@@ -52,17 +52,17 @@ module armarx
class ParameterConstraint {};
class ParameterValueRangeConstraint extends ParameterConstraint
{
- aron::data::AronData min;
- aron::data::AronData max;
+ aron::data::dto::GenericData min;
+ aron::data::dto::GenericData max;
};
class ParameterValueSetConstraint extends ParameterConstraint
{
- aron::data::AronList allowedValues;
+ aron::data::dto::List allowedValues;
};
struct Parameter
{
- aron::type::AronType type;
+ aron::type::dto::GenericType type;
ParameterConstraint constraint;
};
dictionary<string, Parameter> ParameterDescriptionMap;
@@ -115,7 +115,7 @@ module armarx
{
string skillName;
StringStringDictionary stringStringParams;
- aron::data::AronDataDict stringAronParams;
+ aron::data::dto::GenericDataDict stringAronParams;
};
}
}
diff --git a/source/RobotAPI/interface/units/LaserScannerUnit.ice b/source/RobotAPI/interface/units/LaserScannerUnit.ice
index 208f51515387ee99e5dd095719c43482e772fae5..631974396e0de5c50dcd67e73c47da2ad78fa99f 100644
--- a/source/RobotAPI/interface/units/LaserScannerUnit.ice
+++ b/source/RobotAPI/interface/units/LaserScannerUnit.ice
@@ -48,7 +48,7 @@ module armarx
{
float angle;
float distance;
- float intensity;
+// float intensity;
};
struct LaserScannerInfo
diff --git a/source/RobotAPI/libraries/ArmarXObjects/ObjectInfo.cpp b/source/RobotAPI/libraries/ArmarXObjects/ObjectInfo.cpp
index 93bdb0286401d7a47a153cf3da6eda1e16dae93a..fea3677bd5aa3d0d2b762beb32e2c7ff8d6cc9ea 100644
--- a/source/RobotAPI/libraries/ArmarXObjects/ObjectInfo.cpp
+++ b/source/RobotAPI/libraries/ArmarXObjects/ObjectInfo.cpp
@@ -158,7 +158,7 @@ namespace armarx
simox::AxisAlignedBoundingBox aabb(min, max);
- static const float prec = 1e-4f;
+ static const float prec = 1e-3f;
ARMARX_CHECK_LESS_EQUAL((aabb.center() - center).norm(), prec) << aabb.center().transpose() << "\n" << center.transpose() << "\n" << id();
ARMARX_CHECK_LESS_EQUAL((aabb.extents() - extents).norm(), prec) << aabb.extents().transpose() << "\n" << extents.transpose() << "\n" << id();
ARMARX_CHECK_LESS_EQUAL((aabb.min() - min).norm(), prec) << aabb.min().transpose() << "\n" << min.transpose() << "\n" << id();
diff --git a/source/RobotAPI/libraries/DSControllers/Gaussians.h b/source/RobotAPI/libraries/DSControllers/Gaussians.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce2e70ec071f27c2316e8e7bfedbf4604f5ffdec
--- /dev/null
+++ b/source/RobotAPI/libraries/DSControllers/Gaussians.h
@@ -0,0 +1,81 @@
+/*
+ * Gaussians.h
+ *
+ * Created on: Nov 19, 2011
+ * Author: Seungsu KIM
+ */
+
+#ifndef __GAUSSIANSM_H__
+#define __GAUSSIANSM_H__
+
+#include "MathLib.h"
+
+#define GAUSSIAN_MAXIMUM_NUMBER 50
+
+struct GMMState
+{
+ ::MathLib::Vector Mu;
+ ::MathLib::Matrix Sigma;
+ double Prio;
+};
+
+struct GMMStateP
+{
+ MathLib::Vector MuI;
+ MathLib::Matrix SigmaII;
+ MathLib::Matrix SigmaIIInv;
+ double detSigmaII;
+
+ // for GMR
+ MathLib::Vector muO;
+ MathLib::Matrix SigmaIO;
+ MathLib::Matrix SigmaIOInv;
+};
+
+struct GMMs
+{
+ unsigned int nbStates;
+ unsigned int nbDim;
+
+ GMMState States[GAUSSIAN_MAXIMUM_NUMBER];
+};
+
+class Gaussians
+{
+private:
+ GMMStateP gmmpinv[GAUSSIAN_MAXIMUM_NUMBER];
+
+public:
+ GMMs model;
+
+ Gaussians(const char* f_mu, const char* f_sigma, const char* f_prio);
+ Gaussians(int nbStates, int nbDim, const char* f_mu, const char* f_sigma, const char* f_prio);
+ Gaussians(const int nbStates, const int nbDim, const vector<double> pri_vec, const vector<double> mu_vec, const vector<double> sig_vec);
+ Gaussians(GMMs* model);
+
+ void setGMMs(GMMs* model);
+
+ // For fast computation of GaussianPDF
+ MathLib::Vector gfDiff, gfDiffp;
+ MathLib::Vector gDer;
+ MathLib::Vector gPdf;
+ int nbDimI;
+
+
+ void InitFastGaussians(int first_inindex, int last_inindex);
+ double GaussianPDFFast(int state, MathLib::Vector x);
+ double GaussianProbFast(MathLib::Vector x);
+ MathLib::Vector GaussianDerProbFast(MathLib::Vector x);
+
+ void InitFastGMR(int first_inindex, int last_inindex, int first_outindex, int last_outindex);
+ void Regression(const MathLib::Vector& indata, MathLib::Vector& outdata, MathLib::Matrix& derGMR);
+ void Regression(const MathLib::Vector& indata, MathLib::Vector& outdata);
+ MathLib::Vector Regression(const MathLib::Vector& indata);
+
+};
+/*
+void GaussianMux(GMMs *modelK, GMMs *modelL, GMMs *modelOut);
+void GaussianRotate(GMMs *model, Vector P, Matrix R, GMMs *modelOut);
+*/
+
+#endif //__GAUSSIANS_H__
diff --git a/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.cpp b/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.cpp
index 9c998ec1bcf43e235a8eee2706205ea15efe9964..24d050e646d9bbac8ed3ab5fa30926f6b24f442a 100644
--- a/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.cpp
+++ b/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.cpp
@@ -87,10 +87,10 @@ namespace armarx::armem
bool success = true;
- std::map<std::string, std::vector<armarx::aron::datanavigator::DictNavigatorPtr>> updates = {};
+ std::map<std::string, std::vector<armarx::aron::data::DictPtr>> updates = {};
armarx::grasping::arondto::GraspCandidate aronGraspCandidate;
- for (armarx::grasping::GraspCandidatePtr candidate : candidates)
+ for (const auto& candidate : candidates)
{
std::string objectName = "UnknownObject";
if (candidate->sourceInfo)
@@ -102,10 +102,10 @@ namespace armarx::armem
updates[objectName].push_back(aronGraspCandidate.toAron());
}
- for (std::pair<std::string, std::vector<armarx::aron::datanavigator::DictNavigatorPtr>> update : updates)
+ for (const auto& [key, dict] : updates)
{
- if (! commitToMemory(update.second, provider, update.first, timestamp, properties.graspMemoryName))
+ if (! commitToMemory(dict, provider, key, timestamp, properties.graspMemoryName))
{
success = false;
}
@@ -119,7 +119,7 @@ namespace armarx::armem
{
bool success = true;
- std::map<std::string, std::vector<armarx::aron::datanavigator::DictNavigatorPtr>> updates = {};
+ std::map<std::string, std::vector<armarx::aron::data::DictPtr>> updates = {};
armarx::grasping::arondto::BimanualGraspCandidate aronGraspCandidate;
for (armarx::grasping::BimanualGraspCandidatePtr candidate : candidates)
@@ -133,10 +133,10 @@ namespace armarx::armem
updates[objectName].push_back(aronGraspCandidate.toAron());
}
- for (std::pair<std::string, std::vector<armarx::aron::datanavigator::DictNavigatorPtr>> update : updates)
+ for (const auto& [key, dict] : updates)
{
- if (! commitToMemory(update.second, provider, update.first, timestamp, properties.bimanualGraspMemoryName))
+ if (! commitToMemory(dict, provider, key, timestamp, properties.bimanualGraspMemoryName))
{
success = false;
}
@@ -144,7 +144,7 @@ namespace armarx::armem
return success;
}
- bool GraspCandidateWriter::commitToMemory(const std::vector<armarx::aron::datanavigator::DictNavigatorPtr>& instances,
+ bool GraspCandidateWriter::commitToMemory(const std::vector<armarx::aron::data::DictPtr>& instances,
const std::string& providerName, const std::string& entityName, const armem::Time& timestamp,
const std::string& coreMemoryName)
{
diff --git a/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.h b/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.h
index 10dc74821d92d7f7d8005e5ad347df67be9da777..88793cb534cb18af0fefddcd72be4215eaa70e2b 100644
--- a/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.h
+++ b/source/RobotAPI/libraries/GraspingUtility/GraspCandidateWriter.h
@@ -32,7 +32,7 @@ namespace armarx::armem
private:
- bool commitToMemory(const std::vector<armarx::aron::datanavigator::DictNavigatorPtr>& instances,
+ bool commitToMemory(const std::vector<armarx::aron::data::DictPtr>& instances,
const std::string& providerName, const std::string& entityName, const armem::Time& timestamp,
const std::string& coreMemoryName);
diff --git a/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.cpp b/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.cpp
index 6647cf38585cb868a3df29e9c328bbfe8ac3a677..ab4c6fc0955ba5c27018f5dd29d21ca06cd451c4 100644
--- a/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.cpp
+++ b/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.cpp
@@ -80,16 +80,29 @@ namespace armarx::plugins
void RobotUnitComponentPlugin::preOnConnectComponent()
{
- parent<Component>().getProxy(_robotUnit, _robotUnitName);
+ if (not _robotUnitName.empty())
+ {
+ parent<Component>().getProxy(_robotUnit, _robotUnitName);
+ }
}
void RobotUnitComponentPlugin::postCreatePropertyDefinitions(armarx::PropertyDefinitionsPtr& properties)
{
if (!properties->hasDefinition(PROPERTY_NAME))
{
- properties->defineRequiredProperty<std::string>(
- PROPERTY_NAME,
- "Name of the RobotUnit");
+ if (_isRobotUnitOptionalDependency)
+ {
+ properties->defineOptionalProperty<std::string>(
+ PROPERTY_NAME,
+ "",
+ "Name of the RobotUnit");
+ }
+ else
+ {
+ properties->defineRequiredProperty<std::string>(
+ PROPERTY_NAME,
+ "Name of the RobotUnit");
+ }
}
}
@@ -100,7 +113,6 @@ namespace armarx::plugins
void RobotUnitComponentPlugin::setRobotUnitName(const std::string& name)
{
- ARMARX_CHECK_NOT_EMPTY(name);
ARMARX_CHECK_EMPTY(_robotUnitName);
_robotUnitName = name;
}
@@ -110,25 +122,45 @@ namespace armarx::plugins
return _robotUnitName;
}
- void RobotUnitComponentPlugin::deactivate()
+ bool RobotUnitComponentPlugin::hasRobotUnitName() const
{
- _isRobotUnitOptionalDependency = true;
+ return not _robotUnitName.empty();
}
+ void RobotUnitComponentPlugin::setRobotUnitAsOptionalDependency(bool isOptional)
+ {
+ _isRobotUnitOptionalDependency = isOptional;
+ }
- void RobotUnitComponentPlugin::waitUntilRobotUnitIsRunning(const std::function<bool ()>& termCond) const
+ void RobotUnitComponentPlugin::waitUntilRobotUnitIsRunning(const std::function<bool ()>& termCond)
{
ARMARX_INFO << "Waiting until robot unit is running ...";
- while (not(termCond() or not isNullptr(getRobotUnit()) or getRobotUnit()->isRunning()))
+ if (not hasRobotUnitName())
{
+ ARMARX_ERROR << "Could not wait for a robotUnit without a name!";
+ return;
+ }
+
+ parent<Component>().usingProxy(_robotUnitName);
+ while (not(termCond()) and not(robotUnitIsRunning()))
+ {
+ ARMARX_INFO << deactivateSpam() << "Still waiting for robot unit to start...";
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
ARMARX_INFO << "Robot unit is up and running.";
}
-
+ bool RobotUnitComponentPlugin::robotUnitIsRunning() const
+ {
+ if (not hasRobotUnitName())
+ {
+ // An empty robotUnit can never run
+ return false;
+ }
+ return not(isNullptr(getRobotUnit()) and getRobotUnit()->isRunning());
+ }
} // namespace armarx::plugins
diff --git a/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.h b/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.h
index 4371934b97182947afbaad3d60fd5295a717615a..6edd2d83691362e3dfdebb372984ca05f497e586 100644
--- a/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.h
+++ b/source/RobotAPI/libraries/RobotAPIComponentPlugins/RobotUnitComponentPlugin.h
@@ -26,13 +26,9 @@ namespace armarx
void setRobotUnitName(const std::string& name);
const std::string& getRobotUnitName() const;
+ bool hasRobotUnitName() const;
- void deactivate();
-
- void setRobotUnitAsOptionalDependency(bool isOptional = true)
- {
-
- }
+ void setRobotUnitAsOptionalDependency(bool isOptional = true);
/**
* @brief Waits until the robot unit is running.
@@ -44,7 +40,9 @@ namespace armarx
* If it evaluates to true, waitUntilRobotUnitIsRunning returns without waiting
* for the robot unit to become available.
*/
- void waitUntilRobotUnitIsRunning(const std::function<bool()>& termCond = [] {return false;}) const;
+ void waitUntilRobotUnitIsRunning(const std::function<bool()>& termCond = [] {return false;});
+
+ bool robotUnitIsRunning() const;
diff --git a/source/RobotAPI/libraries/armem/CMakeLists.txt b/source/RobotAPI/libraries/armem/CMakeLists.txt
index cf8ce72dfd79c7148548940fc954b4ea10ad1fda..18ddb34929d22aacf507a5a162ab65d30245d585 100644
--- a/source/RobotAPI/libraries/armem/CMakeLists.txt
+++ b/source/RobotAPI/libraries/armem/CMakeLists.txt
@@ -20,6 +20,7 @@ set(LIBS
# Needed for LTM
RobotAPI::aron::converter::json
+ RobotAPI::aron::converter::opencv
${LIBMONGOCXX_LIBRARIES}
${LIBBSONCXX_LIBRARIES}
)
@@ -83,11 +84,38 @@ set(LIB_FILES
server/MemoryRemoteGui.cpp
server/RemoteGuiAronDataVisitor.cpp
- server/ltm/LongtermMemoryBase.cpp
- server/ltm/disk/operations.cpp
- server/ltm/disk/MemoryManager.cpp
- server/ltm/mongodb/MemoryManager.cpp
- server/ltm/mongodb/ConnectionManager.cpp
+ server/ltm/base/detail/MemoryItem.cpp
+ server/ltm/base/detail/MemoryBase.cpp
+ server/ltm/base/detail/BufferedMemoryBase.cpp
+ server/ltm/base/detail/LUTMemoryBase.cpp
+ server/ltm/base/detail/CoreSegmentBase.cpp
+ server/ltm/base/detail/ProviderSegmentBase.cpp
+ server/ltm/base/detail/EntityBase.cpp
+ server/ltm/base/detail/EntitySnapshotBase.cpp
+
+ server/ltm/base/filter/Filter.cpp
+ server/ltm/base/filter/frequencyFilter/FrequencyFilter.cpp
+
+ server/ltm/base/extractor/Extractor.cpp
+ server/ltm/base/extractor/imageExtractor/ImageExtractor.cpp
+ server/ltm/base/extractor/noExtractor/NoExtractor.cpp
+
+ server/ltm/base/converter/dict/Converter.cpp
+ server/ltm/base/converter/dict/json/JsonConverter.cpp
+ server/ltm/base/converter/dict/bson/BsonConverter.cpp
+ server/ltm/base/converter/image/Converter.cpp
+ server/ltm/base/converter/image/png/PngConverter.cpp
+
+ server/ltm/base/forgetter/Forgetter.cpp
+ server/ltm/base/forgetter/LRUForgetter/LRUForgetter.cpp
+
+ server/ltm/disk/detail/Data.cpp
+ server/ltm/disk/detail/DiskStorage.cpp
+ server/ltm/disk/Memory.cpp
+ server/ltm/disk/CoreSegment.cpp
+ server/ltm/disk/ProviderSegment.cpp
+ server/ltm/disk/Entity.cpp
+ server/ltm/disk/EntitySnapshot.cpp
server/wm/memory_definitions.cpp
server/wm/ice_conversions.cpp
@@ -106,8 +134,17 @@ set(LIB_FILES
server/query_proc/base/CoreSegmentQueryProcessorBase.cpp
server/query_proc/base/MemoryQueryProcessorBase.cpp
- server/query_proc/ltm.cpp
- server/query_proc/wm.cpp
+ server/query_proc/ltm/detail/EntityQueryProcessorBase.cpp
+ server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.cpp
+ server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.cpp
+ server/query_proc/ltm/detail/MemoryQueryProcessorBase.cpp
+ server/query_proc/ltm/disk/ltm.cpp
+
+ server/query_proc/wm/detail/EntityQueryProcessorBase.cpp
+ server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.cpp
+ server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.cpp
+ server/query_proc/wm/detail/MemoryQueryProcessorBase.cpp
+ server/query_proc/wm/wm.cpp
mns/MemoryNameSystem.cpp
@@ -196,11 +233,39 @@ set(LIB_HEADERS
server/MemoryRemoteGui.h
server/RemoteGuiAronDataVisitor.h
- server/ltm/LongtermMemoryBase.h
- server/ltm/disk/operations.h
- server/ltm/disk/MemoryManager.h
- server/ltm/mongodb/MemoryManager.h
- server/ltm/mongodb/ConnectionManager.h
+ server/ltm/base/detail/MemoryItem.h
+ server/ltm/base/detail/MemoryBase.h
+ server/ltm/base/detail/BufferedMemoryBase.h
+ server/ltm/base/detail/LUTMemoryBase.h
+ server/ltm/base/detail/CoreSegmentBase.h
+ server/ltm/base/detail/ProviderSegmentBase.h
+ server/ltm/base/detail/EntityBase.h
+ server/ltm/base/detail/EntitySnapshotBase.h
+
+ server/ltm/base/filter/Filter.h
+ server/ltm/base/filter/frequencyFilter/FrequencyFilter.h
+
+ server/ltm/base/extractor/Extractor.h
+ server/ltm/base/extractor/imageExtractor/ImageExtractor.h
+ server/ltm/base/extractor/noExtractor/NoExtractor.h
+
+ server/ltm/base/converter/dict/Converter.h
+ server/ltm/base/converter/dict/json/JsonConverter.h
+ server/ltm/base/converter/dict/bson/BsonConverter.h
+ server/ltm/base/converter/image/Converter.h
+ server/ltm/base/converter/image/png/PngConverter.h
+
+
+ server/ltm/base/forgetter/Forgetter.h
+ server/ltm/base/forgetter/LRUForgetter/LRUForgetter.h
+
+ server/ltm/disk/detail/Data.h
+ server/ltm/disk/detail/DiskStorage.h
+ server/ltm/disk/Memory.h
+ server/ltm/disk/CoreSegment.h
+ server/ltm/disk/ProviderSegment.h
+ server/ltm/disk/Entity.h
+ server/ltm/disk/EntitySnapshot.h
server/wm/memory_definitions.h
server/wm/ice_conversions.h
@@ -223,8 +288,17 @@ set(LIB_HEADERS
server/query_proc/base/CoreSegmentQueryProcessorBase.h
server/query_proc/base/MemoryQueryProcessorBase.h
- server/query_proc/ltm.h
- server/query_proc/wm.h
+ server/query_proc/ltm/detail/EntityQueryProcessorBase.h
+ server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
+ server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
+ server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
+ server/query_proc/ltm/disk/ltm.h
+
+ server/query_proc/wm/detail/EntityQueryProcessorBase.h
+ server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
+ server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
+ server/query_proc/wm/detail/MemoryQueryProcessorBase.h
+ server/query_proc/wm/wm.h
mns.h
diff --git a/source/RobotAPI/libraries/armem/client/MemoryNameSystem.cpp b/source/RobotAPI/libraries/armem/client/MemoryNameSystem.cpp
index 121b2924802c1a8c7d6ab411fd1c88755ee56621..813981444e2f62afc2a7226952d451422ccd2daf 100644
--- a/source/RobotAPI/libraries/armem/client/MemoryNameSystem.cpp
+++ b/source/RobotAPI/libraries/armem/client/MemoryNameSystem.cpp
@@ -25,6 +25,13 @@ namespace armarx::armem::client
}
+ void MemoryNameSystem::initialize(mns::MemoryNameSystemInterfacePrx mns, ManagedIceObject* component)
+ {
+ this->mns = mns;
+ this->component = component;
+ }
+
+
void MemoryNameSystem::update()
{
ARMARX_CHECK_NOT_NULL(mns);
diff --git a/source/RobotAPI/libraries/armem/client/MemoryNameSystem.h b/source/RobotAPI/libraries/armem/client/MemoryNameSystem.h
index 7779ca2d8b1a65b07ef446675685695dc243de58..01bf3aecfdc821d41f2902efd8329fa9e509152a 100644
--- a/source/RobotAPI/libraries/armem/client/MemoryNameSystem.h
+++ b/source/RobotAPI/libraries/armem/client/MemoryNameSystem.h
@@ -82,6 +82,8 @@ namespace armarx::armem::client
MemoryNameSystem(mns::MemoryNameSystemInterfacePrx mns,
ManagedIceObject* component = nullptr);
+ void initialize(mns::MemoryNameSystemInterfacePrx mns, ManagedIceObject* component = nullptr);
+
mns::MemoryNameSystemInterfacePrx getMemoryNameSystem() const;
void getMemoryNameSystem(mns::MemoryNameSystemInterfacePrx mns);
diff --git a/source/RobotAPI/libraries/armem/client/Writer.cpp b/source/RobotAPI/libraries/armem/client/Writer.cpp
index d9f64e4ca4ea068a9beb01807aa1c8fb4f7075be..7ffeeca7a71a8ea312565b4e96cf3833300f0fcd 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.cpp
+++ b/source/RobotAPI/libraries/armem/client/Writer.cpp
@@ -82,7 +82,7 @@ namespace armarx::armem::client
EntityUpdateResult Writer::commit(
const MemoryID& entityID,
- const std::vector<aron::datanavigator::DictNavigatorPtr>& instancesData,
+ const std::vector<aron::data::DictPtr>& instancesData,
Time timeCreated)
{
EntityUpdate update;
diff --git a/source/RobotAPI/libraries/armem/client/Writer.h b/source/RobotAPI/libraries/armem/client/Writer.h
index c63ce8a6fc11ae221caa17dab95dde1c205e1186..1d898bf6e3bc7382e4a4a22318507a3b29ee2cd7 100644
--- a/source/RobotAPI/libraries/armem/client/Writer.h
+++ b/source/RobotAPI/libraries/armem/client/Writer.h
@@ -48,7 +48,7 @@ namespace armarx::armem::client
/// Commit a single entity update.
EntityUpdateResult commit(
const MemoryID& entityID,
- const std::vector<aron::datanavigator::DictNavigatorPtr>& instancesData,
+ const std::vector<aron::data::DictPtr>& instancesData,
Time timeCreated);
// with bare-ice types
diff --git a/source/RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h b/source/RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h
index 7314b32c048ddfff685ad2095d440cf0f515194c..d43c46cc81664a615f7d652de2c6d55bc37faa2a 100644
--- a/source/RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h
+++ b/source/RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h
@@ -17,6 +17,8 @@ namespace armarx::armem::client::plugins
* topic (`MemoryListenerInterface`).
*
* Derive from this plugin user class to receive memory update events.
+ * If your class already inherits from an ice interface, your ice interface might need to inherit from the
+ * MemoryListenerInterface to avoid errors.
*/
class ListeningPluginUser :
virtual public PluginUser,
diff --git a/source/RobotAPI/libraries/armem/client/plugins/Plugin.cpp b/source/RobotAPI/libraries/armem/client/plugins/Plugin.cpp
index 74cf798f6f65d31ee1e4bb2a2ba239c264d9f88b..fd1e600c512cd622963e3f579c649af99948caf9 100644
--- a/source/RobotAPI/libraries/armem/client/plugins/Plugin.cpp
+++ b/source/RobotAPI/libraries/armem/client/plugins/Plugin.cpp
@@ -56,7 +56,7 @@ namespace armarx::armem::client::plugins
if (isMemoryNameSystemEnabled())
{
ARMARX_DEBUG << "Creating MemoryNameSystem client with owning component '" << parent().getName() << "'.";
- memoryNameSystem = MemoryNameSystem(getMemoryNameSystemProxy(), &parent());
+ memoryNameSystem.initialize(getMemoryNameSystemProxy(), &parent());
}
}
diff --git a/source/RobotAPI/libraries/armem/client/util/MemoryListener.cpp b/source/RobotAPI/libraries/armem/client/util/MemoryListener.cpp
index 3318b9ed385ff337b13871fb017fcb521af7fd74..f0ca213f3873dd81ca3b3a02972d04fde3f0cbee 100644
--- a/source/RobotAPI/libraries/armem/client/util/MemoryListener.cpp
+++ b/source/RobotAPI/libraries/armem/client/util/MemoryListener.cpp
@@ -39,8 +39,13 @@ namespace armarx::armem::client::util
{
if (contains(subscription, updatedSnapshotID))
{
+ // ARMARX_IMPORTANT << VAROUT(subscription) << " matches " << VAROUT(updatedSnapshotID);
matchingSnapshotIDs.push_back(updatedSnapshotID);
}
+ else
+ {
+ // ARMARX_IMPORTANT << VAROUT(subscription) << " does not match " << VAROUT(updatedSnapshotID);
+ }
}
catch (const armem::error::InvalidMemoryID& e)
{
diff --git a/source/RobotAPI/libraries/armem/core/Commit.cpp b/source/RobotAPI/libraries/armem/core/Commit.cpp
index db5f1b630e84ff276901f3321dd2a3fbbccc0442..a29354a4374653f8b0ccfb0fc60f3783656acf1e 100644
--- a/source/RobotAPI/libraries/armem/core/Commit.cpp
+++ b/source/RobotAPI/libraries/armem/core/Commit.cpp
@@ -1,6 +1,6 @@
#include "Commit.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
diff --git a/source/RobotAPI/libraries/armem/core/Commit.h b/source/RobotAPI/libraries/armem/core/Commit.h
index 685886a7f27b5d43b78cd0195693e32c3a58fffa..433703a5ac8bc3f05727cffa86be073781c4dcf1 100644
--- a/source/RobotAPI/libraries/armem/core/Commit.h
+++ b/source/RobotAPI/libraries/armem/core/Commit.h
@@ -3,7 +3,7 @@
#include <RobotAPI/libraries/armem/core/Time.h>
#include <RobotAPI/libraries/armem/core/MemoryID.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
#include <memory>
#include <vector>
@@ -30,7 +30,7 @@ namespace armarx::armem
MemoryID entityID;
/// The entity data.
- std::vector<aron::datanavigator::DictNavigatorPtr> instancesData;
+ std::vector<aron::data::DictPtr> instancesData;
/**
* @brief Time when this entity update was created (e.g. time of image recording).
diff --git a/source/RobotAPI/libraries/armem/core/base/CoreSegmentBase.h b/source/RobotAPI/libraries/armem/core/base/CoreSegmentBase.h
index 4f63c6f3a5cb14ad61f4d4664ead485c78345938..8f158a3fe744a36ab4bf7755e1fee362bc01a6f8 100644
--- a/source/RobotAPI/libraries/armem/core/base/CoreSegmentBase.h
+++ b/source/RobotAPI/libraries/armem/core/base/CoreSegmentBase.h
@@ -9,6 +9,7 @@
#include "detail/iteration_mixins.h"
#include "detail/lookup_mixins.h"
+#include <ArmarXCore/core/logging/Logging.h>
namespace armarx::armem::base
{
@@ -65,15 +66,15 @@ namespace armarx::armem::base
CoreSegmentBase()
{
}
- explicit CoreSegmentBase(const std::string& name, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit CoreSegmentBase(const std::string& name, aron::type::ObjectPtr aronType = nullptr) :
CoreSegmentBase(name, MemoryID(), aronType)
{
}
- explicit CoreSegmentBase(const std::string& name, const MemoryID& parentID, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit CoreSegmentBase(const std::string& name, const MemoryID& parentID, aron::type::ObjectPtr aronType = nullptr) :
CoreSegmentBase(parentID.withCoreSegmentName(name), aronType)
{
}
- explicit CoreSegmentBase(const MemoryID& id, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit CoreSegmentBase(const MemoryID& id, aron::type::ObjectPtr aronType = nullptr) :
Base(id),
AronTyped(aronType)
{
@@ -268,9 +269,9 @@ namespace armarx::armem::base
* @param providerSegmentType The provider type. If nullptr, the core segment type is used.
* @return The added provider segment.
*/
- ProviderSegmentT& addProviderSegment(const std::string& name, aron::typenavigator::ObjectNavigatorPtr providerSegmentType = nullptr)
+ ProviderSegmentT& addProviderSegment(const std::string& name, aron::type::ObjectPtr providerSegmentType = nullptr)
{
- aron::typenavigator::ObjectNavigatorPtr type = providerSegmentType ? providerSegmentType : this->aronType();
+ aron::type::ObjectPtr type = providerSegmentType ? providerSegmentType : this->aronType();
return this->_derived().addProviderSegment(name, name, type);
}
diff --git a/source/RobotAPI/libraries/armem/core/base/MemoryBase.h b/source/RobotAPI/libraries/armem/core/base/MemoryBase.h
index 2d28474e232281c085cad9a88cd0dcd85fec70d0..0bb30f68996ea1d292b1c4b599c4ee1b98e5dc36 100644
--- a/source/RobotAPI/libraries/armem/core/base/MemoryBase.h
+++ b/source/RobotAPI/libraries/armem/core/base/MemoryBase.h
@@ -209,7 +209,7 @@ namespace armarx::armem::base
* @return The added core segment.
*/
CoreSegmentT& addCoreSegment(
- const std::string& name, aron::typenavigator::ObjectNavigatorPtr coreSegmentType = nullptr)
+ const std::string& name, aron::type::ObjectPtr coreSegmentType = nullptr)
{
return this->_derived().addCoreSegment(name, name, coreSegmentType);
}
diff --git a/source/RobotAPI/libraries/armem/core/base/ProviderSegmentBase.h b/source/RobotAPI/libraries/armem/core/base/ProviderSegmentBase.h
index a2a9f2a8c8ae6b57ff33ce1ecf8d1d1b5710ff55..7deccd83643bc759a289dd6340f16452994ccab1 100644
--- a/source/RobotAPI/libraries/armem/core/base/ProviderSegmentBase.h
+++ b/source/RobotAPI/libraries/armem/core/base/ProviderSegmentBase.h
@@ -60,15 +60,15 @@ namespace armarx::armem::base
{
}
- explicit ProviderSegmentBase(const std::string& name, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit ProviderSegmentBase(const std::string& name, aron::type::ObjectPtr aronType = nullptr) :
ProviderSegmentBase(name, MemoryID(), aronType)
{
}
- explicit ProviderSegmentBase(const std::string& name, const MemoryID parentID, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit ProviderSegmentBase(const std::string& name, const MemoryID parentID, aron::type::ObjectPtr aronType = nullptr) :
ProviderSegmentBase(parentID.withProviderSegmentName(name), aronType)
{
}
- explicit ProviderSegmentBase(const MemoryID id, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr) :
+ explicit ProviderSegmentBase(const MemoryID id, aron::type::ObjectPtr aronType = nullptr) :
Base(id),
AronTyped(aronType)
{
diff --git a/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.cpp b/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.cpp
index 48147758528cb5ac46baa8a952272ee831ed1e01..488b02830061c4c391e77e85875f34987051c90b 100644
--- a/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.cpp
+++ b/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.cpp
@@ -1,12 +1,12 @@
#include "AronTyped.h"
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
namespace armarx::armem::base::detail
{
- AronTyped::AronTyped(aron::typenavigator::ObjectNavigatorPtr aronType) :
+ AronTyped::AronTyped(aron::type::ObjectPtr aronType) :
_aronType(aronType)
{}
@@ -15,12 +15,12 @@ namespace armarx::armem::base::detail
return _aronType != nullptr;
}
- aron::typenavigator::ObjectNavigatorPtr& AronTyped::aronType()
+ aron::type::ObjectPtr& AronTyped::aronType()
{
return _aronType;
}
- aron::typenavigator::ObjectNavigatorPtr AronTyped::aronType() const
+ aron::type::ObjectPtr AronTyped::aronType() const
{
return _aronType;
}
diff --git a/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.h b/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.h
index 16233556c83f8febb732824a7001c9b2e8d1e2ac..04537a1be95b88147f68091334195e601298bd77 100644
--- a/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.h
+++ b/source/RobotAPI/libraries/armem/core/base/detail/AronTyped.h
@@ -1,6 +1,6 @@
#pragma once
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/type/variant/forward_declarations.h>
namespace armarx::armem::base::detail
@@ -13,18 +13,18 @@ namespace armarx::armem::base::detail
{
public:
- explicit AronTyped(aron::typenavigator::ObjectNavigatorPtr aronType = nullptr);
+ explicit AronTyped(aron::type::ObjectPtr aronType = nullptr);
bool hasAronType() const;
- aron::typenavigator::ObjectNavigatorPtr& aronType();
- aron::typenavigator::ObjectNavigatorPtr aronType() const;
+ aron::type::ObjectPtr& aronType();
+ aron::type::ObjectPtr aronType() const;
protected:
/// The expected Aron type. May be nullptr, in which case no type information is available.
- aron::typenavigator::ObjectNavigatorPtr _aronType;
+ aron::type::ObjectPtr _aronType;
};
diff --git a/source/RobotAPI/libraries/armem/core/base/ice_conversions.cpp b/source/RobotAPI/libraries/armem/core/base/ice_conversions.cpp
index 48c084154c41b26b174504d2565fe57d3a49d55a..d2339f87f009bd35a3b78812555e652884719238 100644
--- a/source/RobotAPI/libraries/armem/core/base/ice_conversions.cpp
+++ b/source/RobotAPI/libraries/armem/core/base/ice_conversions.cpp
@@ -1,7 +1,7 @@
#include "ice_conversions.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <RobotAPI/libraries/armem/core/ice_conversions.h>
#include <RobotAPI/libraries/armem/core/ice_conversions_templates.h>
@@ -20,15 +20,15 @@ namespace armarx::armem::base
}
- void detail::toIce(aron::data::AronDictPtr& ice, const aron::datanavigator::DictNavigatorPtr& data)
+ void detail::toIce(aron::data::dto::DictPtr& ice, const aron::data::DictPtr& data)
{
ice = data ? data->toAronDictPtr() : nullptr;
}
- void detail::fromIce(const aron::data::AronDictPtr& ice, aron::datanavigator::DictNavigatorPtr& data)
+ void detail::fromIce(const aron::data::dto::DictPtr& ice, aron::data::DictPtr& data)
{
if (ice)
{
- data = aron::datanavigator::DictNavigator::FromAronDictPtr(ice);
+ data = aron::data::Dict::FromAronDictPtr(ice);
}
else
{
@@ -36,14 +36,14 @@ namespace armarx::armem::base
};
}
- void detail::toIce(aron::type::AronTypePtr& ice, const aron::typenavigator::ObjectNavigatorPtr& bo)
+ void detail::toIce(aron::type::dto::GenericTypePtr& ice, const aron::type::ObjectPtr& bo)
{
- ice = bo ? bo->toAronPtr() : nullptr;
+ ice = bo ? bo->toAronDTO() : nullptr;
}
- void detail::fromIce(const aron::type::AronTypePtr& ice, aron::typenavigator::ObjectNavigatorPtr& bo)
+ void detail::fromIce(const aron::type::dto::GenericTypePtr& ice, aron::type::ObjectPtr& bo)
{
bo = ice
- ? aron::typenavigator::ObjectNavigator::DynamicCastAndCheck(aron::typenavigator::Navigator::FromAronType(ice))
+ ? aron::type::Object::DynamicCastAndCheck(aron::type::Variant::FromAronDTO(*ice))
: nullptr;
}
diff --git a/source/RobotAPI/libraries/armem/core/base/ice_conversions.h b/source/RobotAPI/libraries/armem/core/base/ice_conversions.h
index 182e0c0a47aff1a75b356b9cc0b3930450de75e4..21316623c9484f46db177d122642170822561c13 100644
--- a/source/RobotAPI/libraries/armem/core/base/ice_conversions.h
+++ b/source/RobotAPI/libraries/armem/core/base/ice_conversions.h
@@ -10,7 +10,7 @@
#include <RobotAPI/libraries/armem/core/ice_conversions_templates.h>
#include <RobotAPI/libraries/armem/core/ice_conversions.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/type/variant/forward_declarations.h>
#include <RobotAPI/interface/armem/memory.h>
@@ -22,11 +22,11 @@ namespace armarx::armem::base::detail
void toIceItem(data::detail::MemoryItem& ice, const MemoryItem& item);
void fromIceItem(const data::detail::MemoryItem& ice, MemoryItem& item);
- void toIce(aron::data::AronDictPtr& ice, const aron::datanavigator::DictNavigatorPtr& bo);
- void fromIce(const aron::data::AronDictPtr& ice, aron::datanavigator::DictNavigatorPtr& bo);
+ void toIce(aron::data::dto::DictPtr& ice, const aron::data::DictPtr& bo);
+ void fromIce(const aron::data::dto::DictPtr& ice, aron::data::DictPtr& bo);
- void toIce(aron::type::AronTypePtr& ice, const aron::typenavigator::ObjectNavigatorPtr& bo);
- void fromIce(const aron::type::AronTypePtr& ice, aron::typenavigator::ObjectNavigatorPtr& bo);
+ void toIce(aron::type::dto::GenericTypePtr& ice, const aron::type::ObjectPtr& bo);
+ void fromIce(const aron::type::dto::GenericTypePtr& ice, aron::type::ObjectPtr& bo);
}
namespace armarx::armem::base
{
diff --git a/source/RobotAPI/libraries/armem/core/ice_conversions.cpp b/source/RobotAPI/libraries/armem/core/ice_conversions.cpp
index cca45a3b2cf04f26ec76d158e9cf1e711bbfecb2..f019f3d78a9ed3a38116ee86a11ef42ef942e9d4 100644
--- a/source/RobotAPI/libraries/armem/core/ice_conversions.cpp
+++ b/source/RobotAPI/libraries/armem/core/ice_conversions.cpp
@@ -1,6 +1,6 @@
#include "ice_conversions.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
void IceUtil::toIce(long& ice, const IceUtil::Time& time)
@@ -36,7 +36,6 @@ namespace armarx
id.instanceIndex = ice.instanceIndex;
}
-
void armem::fromIce(const data::Commit& ice, Commit& commit)
{
commit.updates.clear();
@@ -57,7 +56,6 @@ namespace armarx
}
}
-
void armem::fromIce(const data::CommitResult& ice, CommitResult& result)
{
result.results.clear();
@@ -78,7 +76,6 @@ namespace armarx
}
}
-
void armem::fromIce(const data::EntityUpdate& ice, EntityUpdate& update)
{
fromIce(ice.entityID, update.entityID);
@@ -86,7 +83,7 @@ namespace armarx
update.instancesData.clear();
update.instancesData.reserve(ice.instancesData.size());
std::transform(ice.instancesData.begin(), ice.instancesData.end(), std::back_inserter(update.instancesData),
- aron::datanavigator::DictNavigator::FromAronDictPtr);
+ aron::data::Dict::FromAronDictPtr);
update.timeCreated = Time::microSeconds(ice.timeCreatedMicroSeconds);
@@ -101,7 +98,7 @@ namespace armarx
ice.instancesData.clear();
ice.instancesData.reserve(update.instancesData.size());
std::transform(update.instancesData.begin(), update.instancesData.end(), std::back_inserter(ice.instancesData),
- aron::datanavigator::DictNavigator::ToAronDictPtr);
+ aron::data::Dict::ToAronDictPtr);
ice.timeCreatedMicroSeconds = update.timeCreated.toMicroSeconds();
@@ -109,7 +106,6 @@ namespace armarx
ice.timeSentMicroSeconds = update.timeSent.toMicroSeconds();
}
-
void armem::fromIce(const data::EntityUpdateResult& ice, EntityUpdateResult& result)
{
result.success = ice.success;
@@ -126,7 +122,6 @@ namespace armarx
ice.errorMessage = result.errorMessage;
}
-
void armem::fromIce(const data::Commit& ice, Commit& commit, Time timeArrived)
{
commit.updates.clear();
@@ -137,7 +132,6 @@ namespace armarx
}
}
-
void armem::fromIce(const data::EntityUpdate& ice, EntityUpdate& update, Time timeArrived)
{
armem::fromIce(ice, update);
diff --git a/source/RobotAPI/libraries/armem/core/operations.cpp b/source/RobotAPI/libraries/armem/core/operations.cpp
index 533bc623f3844a06ab7b87d858c00942a637fcbc..51729c613b6d10e5903a92818d9e1b4fa507fa11 100644
--- a/source/RobotAPI/libraries/armem/core/operations.cpp
+++ b/source/RobotAPI/libraries/armem/core/operations.cpp
@@ -8,10 +8,10 @@
namespace armarx
{
- std::vector<aron::datanavigator::DictNavigatorPtr>
+ std::vector<aron::data::DictPtr>
armem::getAronData(const wm::EntitySnapshot& snapshot)
{
- std::vector<aron::datanavigator::DictNavigatorPtr> result;
+ std::vector<aron::data::DictPtr> result;
snapshot.forEachChild([&result](const wm::EntityInstance & instance)
{
result.push_back(instance.data());
diff --git a/source/RobotAPI/libraries/armem/core/operations.h b/source/RobotAPI/libraries/armem/core/operations.h
index 775b6dd07216a13dcffafc73f8651f6722b56b09..f1300da6a0d20f6685bc358494d9997c7e4bdb17 100644
--- a/source/RobotAPI/libraries/armem/core/operations.h
+++ b/source/RobotAPI/libraries/armem/core/operations.h
@@ -14,7 +14,7 @@
namespace armarx::armem
{
- std::vector<aron::datanavigator::DictNavigatorPtr>
+ std::vector<aron::data::DictPtr>
getAronData(const wm::EntitySnapshot& snapshot);
diff --git a/source/RobotAPI/libraries/armem/core/wm/aron_conversions.cpp b/source/RobotAPI/libraries/armem/core/wm/aron_conversions.cpp
index a4a5faa1404129feed5f2573c706c22900c108df..91b1a6584269820bfc020b36145cd656feec76d4 100644
--- a/source/RobotAPI/libraries/armem/core/wm/aron_conversions.cpp
+++ b/source/RobotAPI/libraries/armem/core/wm/aron_conversions.cpp
@@ -1,69 +1,64 @@
#include "aron_conversions.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
namespace armarx::armem
{
-
- constexpr const char* DATA_WRAPPER_DATA_FIELD = "__ARON_DATA";
constexpr const char* DATA_WRAPPER_TIME_STORED_FIELD = "__WRITER_METADATA__TIME_STORED";
constexpr const char* DATA_WRAPPER_TIME_CREATED_FIELD = "__ENTITY_METADATA__TIME_CREATED";
constexpr const char* DATA_WRAPPER_TIME_SENT_FIELD = "__ENTITY_METADATA__TIME_SENT";
constexpr const char* DATA_WRAPPER_TIME_ARRIVED_FIELD = "__ENTITY_METADATA__TIME_ARRIVED";
constexpr const char* DATA_WRAPPER_CONFIDENCE_FIELD = "__ENTITY_METADATA__CONFIDENCE";
-
}
-void armarx::armem::from_aron(const aron::datanavigator::DictNavigatorPtr& dataWrapped, wm::EntityInstance& e)
+void armarx::armem::from_aron(const aron::data::DictPtr& metadata, const aron::data::DictPtr& data, wm::EntityInstance& e)
{
- wm::EntityInstanceMetadata& metadata = e.metadata();
+ ARMARX_CHECK_NOT_NULL(metadata);
+ // Todo: What if data is null?
+
+ wm::EntityInstanceMetadata& m = e.metadata();
- if (dataWrapped->hasElement(DATA_WRAPPER_DATA_FIELD))
- {
- e.data() = aron::datanavigator::DictNavigator::DynamicCastAndCheck(dataWrapped->getElement(DATA_WRAPPER_DATA_FIELD));
- }
+ e.data() = data;
- auto timeCreated = aron::datanavigator::LongNavigator::DynamicCastAndCheck(dataWrapped->getElement(DATA_WRAPPER_TIME_CREATED_FIELD));
- metadata.timeCreated = Time::microSeconds(timeCreated->toAronLongPtr()->value);
+ auto timeCreated = aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_CREATED_FIELD));
+ m.timeCreated = Time::microSeconds(timeCreated->toAronLongPtr()->value);
- auto timeSent = aron::datanavigator::LongNavigator::DynamicCastAndCheck(dataWrapped->getElement(DATA_WRAPPER_TIME_SENT_FIELD));
- metadata.timeSent = Time::microSeconds(timeSent->toAronLongPtr()->value);
+ auto timeSent = aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_SENT_FIELD));
+ m.timeSent = Time::microSeconds(timeSent->toAronLongPtr()->value);
- auto timeArrived = aron::datanavigator::LongNavigator::DynamicCastAndCheck(dataWrapped->getElement(DATA_WRAPPER_TIME_ARRIVED_FIELD));
- metadata.timeArrived = Time::microSeconds(timeArrived->toAronLongPtr()->value);
+ auto timeArrived = aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_ARRIVED_FIELD));
+ m.timeArrived = Time::microSeconds(timeArrived->toAronLongPtr()->value);
- auto confidence = aron::datanavigator::DoubleNavigator::DynamicCastAndCheck(dataWrapped->getElement(DATA_WRAPPER_CONFIDENCE_FIELD));
- metadata.confidence = static_cast<float>(confidence->toAronDoublePtr()->value);
+ auto confidence = aron::data::Double::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_CONFIDENCE_FIELD));
+ m.confidence = static_cast<float>(confidence->toAronDoublePtr()->value);
}
-void armarx::armem::to_aron(aron::datanavigator::DictNavigatorPtr& a, const wm::EntityInstance& e)
+void armarx::armem::to_aron(aron::data::DictPtr& metadata, aron::data::DictPtr& data, const wm::EntityInstance& e)
{
- if (e.data())
- {
- a->addElement(DATA_WRAPPER_DATA_FIELD, e.data());
- }
+ data = e.data();
+ metadata = std::make_shared<aron::data::Dict>();
- auto timeWrapped = std::make_shared<aron::datanavigator::LongNavigator>();
+ auto timeWrapped = std::make_shared<aron::data::Long>();
timeWrapped->setValue(Time::now().toMicroSeconds());
- a->addElement(DATA_WRAPPER_TIME_STORED_FIELD, timeWrapped);
+ metadata->addElement(DATA_WRAPPER_TIME_STORED_FIELD, timeWrapped);
- const wm::EntityInstanceMetadata& metadata = e.metadata();
- auto timeCreated = std::make_shared<aron::datanavigator::LongNavigator>();
- timeCreated->setValue(metadata.timeCreated.toMicroSeconds());
- a->addElement(DATA_WRAPPER_TIME_CREATED_FIELD, timeCreated);
+ const wm::EntityInstanceMetadata& m = e.metadata();
+ auto timeCreated = std::make_shared<aron::data::Long>();
+ timeCreated->setValue(m.timeCreated.toMicroSeconds());
+ metadata->addElement(DATA_WRAPPER_TIME_CREATED_FIELD, timeCreated);
- auto timeSent = std::make_shared<aron::datanavigator::LongNavigator>();
- timeSent->setValue(metadata.timeSent.toMicroSeconds());
- a->addElement(DATA_WRAPPER_TIME_SENT_FIELD, timeSent);
+ auto timeSent = std::make_shared<aron::data::Long>();
+ timeSent->setValue(m.timeSent.toMicroSeconds());
+ metadata->addElement(DATA_WRAPPER_TIME_SENT_FIELD, timeSent);
- auto timeArrived = std::make_shared<aron::datanavigator::LongNavigator>();
- timeArrived->setValue(metadata.timeArrived.toMicroSeconds());
- a->addElement(DATA_WRAPPER_TIME_ARRIVED_FIELD, timeArrived);
+ auto timeArrived = std::make_shared<aron::data::Long>();
+ timeArrived->setValue(m.timeArrived.toMicroSeconds());
+ metadata->addElement(DATA_WRAPPER_TIME_ARRIVED_FIELD, timeArrived);
- auto confidence = std::make_shared<aron::datanavigator::DoubleNavigator>();
- confidence->setValue(static_cast<double>(metadata.confidence));
- a->addElement(DATA_WRAPPER_CONFIDENCE_FIELD, confidence);
+ auto confidence = std::make_shared<aron::data::Double>();
+ confidence->setValue(static_cast<double>(m.confidence));
+ metadata->addElement(DATA_WRAPPER_CONFIDENCE_FIELD, confidence);
}
diff --git a/source/RobotAPI/libraries/armem/core/wm/aron_conversions.h b/source/RobotAPI/libraries/armem/core/wm/aron_conversions.h
index f6b43dc8bd468008b9fe8ee470564f5de89e16cb..d5de002ba8e74b961c8ec28f341e8a15778c0001 100644
--- a/source/RobotAPI/libraries/armem/core/wm/aron_conversions.h
+++ b/source/RobotAPI/libraries/armem/core/wm/aron_conversions.h
@@ -1,12 +1,15 @@
#pragma once
-#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
namespace armarx::armem
{
- void from_aron(const aron::datanavigator::DictNavigatorPtr&, wm::EntityInstance&);
- void to_aron(aron::datanavigator::DictNavigatorPtr&, const wm::EntityInstance&);
+ /// convert from metadata and data aron instance
+ void from_aron(const aron::data::DictPtr& metadata, const aron::data::DictPtr& data, wm::EntityInstance&);
+
+ /// convert to metadata and aron instance
+ void to_aron(aron::data::DictPtr& metadata, aron::data::DictPtr& data, const wm::EntityInstance&);
}
diff --git a/source/RobotAPI/libraries/armem/core/wm/detail/data_lookup_mixins.h b/source/RobotAPI/libraries/armem/core/wm/detail/data_lookup_mixins.h
index c2d240e2977e1a11df3d8959a4f4200382d8650c..68619e58b0f5705403d98480f6a1b369f2d606e3 100644
--- a/source/RobotAPI/libraries/armem/core/wm/detail/data_lookup_mixins.h
+++ b/source/RobotAPI/libraries/armem/core/wm/detail/data_lookup_mixins.h
@@ -3,7 +3,7 @@
#include <RobotAPI/libraries/armem/core/forward_declarations.h>
#include <RobotAPI/libraries/armem/core/base/detail/derived.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
#include <optional>
@@ -15,7 +15,7 @@ namespace armarx::armem::wm::detail
template <class AronDtoT>
std::optional<AronDtoT>
- getInstanceDataAs(aron::datanavigator::DictNavigatorPtr data)
+ getInstanceDataAs(aron::data::DictPtr data)
{
if (data)
{
@@ -35,7 +35,7 @@ namespace armarx::armem::wm::detail
struct FindInstanceDataMixinForSnapshot
{
- aron::datanavigator::DictNavigatorPtr
+ aron::data::DictPtr
findInstanceData(int instanceIndex = 0) const
{
const auto* instance = derived<DerivedT>(this).findInstance(instanceIndex);
@@ -58,7 +58,7 @@ namespace armarx::armem::wm::detail
struct FindInstanceDataMixinForEntity
{
- aron::datanavigator::DictNavigatorPtr
+ aron::data::DictPtr
findLatestInstanceData(int instanceIndex = 0) const
{
const auto* instance = derived<DerivedT>(this).findLatestInstance(instanceIndex);
@@ -81,7 +81,7 @@ namespace armarx::armem::wm::detail
struct FindInstanceDataMixin
{
- aron::datanavigator::DictNavigatorPtr
+ aron::data::DictPtr
findLatestInstanceData(const MemoryID& entityID, int instanceIndex = 0) const
{
const auto* instance = derived<DerivedT>(this).findLatestInstance(entityID, instanceIndex);
diff --git a/source/RobotAPI/libraries/armem/core/wm/memory_definitions.cpp b/source/RobotAPI/libraries/armem/core/wm/memory_definitions.cpp
index de5ad02c2e9e4f24304c2ae9b9eb97f0cd3e53ee..0758020be61e3326c6b870b8bffae8d06e318a79 100644
--- a/source/RobotAPI/libraries/armem/core/wm/memory_definitions.cpp
+++ b/source/RobotAPI/libraries/armem/core/wm/memory_definitions.cpp
@@ -2,7 +2,7 @@
#include "error.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <map>
diff --git a/source/RobotAPI/libraries/armem/core/wm/memory_definitions.h b/source/RobotAPI/libraries/armem/core/wm/memory_definitions.h
index b77ea3c6e9eb17b69ce3feb848951012a0ed0304..642cc50eda5e34a90e482c7bc5b26d48e3847081 100644
--- a/source/RobotAPI/libraries/armem/core/wm/memory_definitions.h
+++ b/source/RobotAPI/libraries/armem/core/wm/memory_definitions.h
@@ -9,15 +9,14 @@
#include <RobotAPI/libraries/armem/core/base/CoreSegmentBase.h>
#include <RobotAPI/libraries/armem/core/base/MemoryBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
namespace armarx::armem::wm
{
-
using EntityInstanceMetadata = base::EntityInstanceMetadata;
- using EntityInstanceData = armarx::aron::datanavigator::DictNavigator;
- using EntityInstanceDataPtr = armarx::aron::datanavigator::DictNavigatorPtr;
+ using EntityInstanceData = armarx::aron::data::Dict;
+ using EntityInstanceDataPtr = armarx::aron::data::DictPtr;
/// @see base::EntityInstanceBase
diff --git a/source/RobotAPI/libraries/armem/server/MemoryRemoteGui.cpp b/source/RobotAPI/libraries/armem/server/MemoryRemoteGui.cpp
index 57b495a527d07924176314edc70fbfa1c53f1cae..1f0014207719d7fa996d66b0fdfde4d0f04ccfec 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryRemoteGui.cpp
+++ b/source/RobotAPI/libraries/armem/server/MemoryRemoteGui.cpp
@@ -2,9 +2,8 @@
#include "RemoteGuiAronDataVisitor.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
@@ -39,7 +38,7 @@ namespace armarx::armem::server
std::stringstream type;
if (typed.aronType())
{
- type << " (" << typed.aronType()->getName() << ")";
+ type << " (" << typed.aronType()->getFullName() << ")";
}
else
{
@@ -195,9 +194,9 @@ namespace armarx::armem::server
if (instance.data())
{
- RemoteGuiAronDataVisitor visitor;
- visitor.applyTo(*instance.data());
- group = visitor.result;
+ RemoteGuiAronDataVisitor v;
+ aron::data::visitRecursive(v, instance.data());
+ group = v.result;
}
else
{
diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
index 73d00c3a370fd14e40771df77d0d96cc6b9dbf42..a42d4305d7a1845544952e4d9933072f88ac14a6 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
@@ -1,7 +1,7 @@
#include "MemoryToIceAdapter.h"
-#include "query_proc/wm.h"
-#include "query_proc/ltm.h"
+#include "query_proc/wm/wm.h"
+#include "query_proc/ltm/disk/ltm.h"
#include <RobotAPI/libraries/armem/server/wm/ice_conversions.h>
@@ -17,8 +17,8 @@
namespace armarx::armem::server
{
- MemoryToIceAdapter::MemoryToIceAdapter(wm::Memory* workingMemory, server::ltm::mongodb::MemoryManager* longtermMemory) :
- workingMemory(workingMemory), longtermMemoryManager(longtermMemory)
+ MemoryToIceAdapter::MemoryToIceAdapter(wm::Memory* workingMemory, server::ltm::disk::Memory* longtermMemory) :
+ workingMemory(workingMemory), longtermMemory(longtermMemory)
{
}
@@ -186,17 +186,43 @@ namespace armarx::armem::server
result.snapshotID = updateResult.id;
result.timeArrived = update.timeArrived;
- // also store in ltm if transfermode is set to always
- // TODO: Move outside of loop?
- if (longtermMemoryManager)
+ for (const auto& snapshot : updateResult.removedSnapshots)
{
-
+ ARMARX_DEBUG << "The id " << snapshot.id() << " was removed from wm";
}
- // TODO: Consollidate to ltm if onFilledTransfer is enabled (fabian.peller)
- for (const auto& snapshot : updateResult.removedSnapshots)
+ // Consollidate to ltm
+ if (longtermMemory->enabled)
{
- ARMARX_DEBUG << "The id " << snapshot.id() << " was removed from wm";
+ //ARMARX_IMPORTANT << longtermMemory->id().str();
+ //ARMARX_IMPORTANT << longtermMemory->getPath();
+
+ // Create Memory out of list TODO: make nicer
+ armem::wm::Memory m(longtermMemory->name());
+ for (const auto& snapshot : updateResult.removedSnapshots)
+ {
+ if (!m.hasCoreSegment(snapshot.id().coreSegmentName))
+ {
+ m.addCoreSegment(snapshot.id().coreSegmentName);
+ }
+ auto* c = m.findCoreSegment(snapshot.id().coreSegmentName);
+
+ if (!c->hasProviderSegment(snapshot.id().providerSegmentName))
+ {
+ c->addProviderSegment(snapshot.id().providerSegmentName);
+ }
+ auto* p = c->findProviderSegment(snapshot.id().providerSegmentName);
+
+ if (!p->hasEntity(snapshot.id().entityName))
+ {
+ p->addEntity(snapshot.id().entityName);
+ }
+ auto* e = p->findEntity(snapshot.id().entityName);
+
+ e->addSnapshot(snapshot);
+ }
+ longtermMemory->store(m);
+ longtermMemory->storeBuffer();
}
if (publishUpdates)
@@ -237,54 +263,54 @@ namespace armarx::armem::server
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(workingMemory);
+ ARMARX_CHECK_NOT_NULL(longtermMemory);
// Core segment processors will aquire the core segment locks.
query_proc::wm_server::MemoryQueryProcessor wmServerProcessor(
input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
armem::wm::Memory wmResult = wmServerProcessor.process(input.memoryQueries, *workingMemory);
- query_proc::ltm::MemoryQueryProcessor ltmProcessor;
- armem::wm::Memory ltmResult = ltmProcessor.process(input, longtermMemoryManager->getCacheAndLutNotConverted());
-
armem::query::data::Result result;
- if (not ltmResult.empty())
- {
- ARMARX_INFO << "The LTM returned data after query";
- longtermMemoryManager->convert(ltmResult); // convert memory ==> meaning resolving lut references to e.g. mongodb
+ if (longtermMemory->enabled)
+ {
+ query_proc::ltm_server::disk::MemoryQueryProcessor ltmProcessor;
+ armem::wm::Memory ltmResult = ltmProcessor.process(input, *longtermMemory);
- wmResult.append(ltmResult);
- if (wmResult.empty())
+ if (not ltmResult.empty())
{
- ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
- }
+ ARMARX_INFO << "The LTM returned data after query";
- // query again to limit output size (TODO: Skip if querytype is all)
- auto queryInput = armem::client::QueryInput::fromIce(input);
- queryInput.replaceQueryTarget(query::data::QueryTarget::LTM, query::data::QueryTarget::WM);
+ longtermMemory->load(ltmResult); // convert memory ==> meaning resolving references
- query_proc::wm::MemoryQueryProcessor wm2wmProcessor(
- input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
- armem::wm::Memory mergedResult = wm2wmProcessor.process(queryInput.toIce(), wmResult);
- if (mergedResult.empty())
- {
- ARMARX_ERROR << "A merged and postprocessed Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
- }
+ wmResult.append(ltmResult);
+ if (wmResult.empty())
+ {
+ ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
+ }
+
+ // query again to limit output size (TODO: Skip if querytype is all)
+ auto queryInput = armem::client::QueryInput::fromIce(input);
+ queryInput.replaceQueryTarget(query::data::QueryTarget::LTM, query::data::QueryTarget::WM);
- result.memory = toIce<data::MemoryPtr>(mergedResult);
+ query_proc::wm::MemoryQueryProcessor wm2wmProcessor(
+ input.withData ? armem::DataMode::WithData : armem::DataMode::NoData);
+ wmResult = wm2wmProcessor.process(queryInput.toIce(), wmResult);
+ if (wmResult.empty())
+ {
+ ARMARX_ERROR << "A merged and postprocessed Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
+ }
- // also move results of ltm to wm
- //this->commit(toCommit(ltm_converted));
+ // also move results of ltm to wm
+ //this->commit(toCommit(ltm_converted));
- // mark removed entries of wm in viewer
- // TODO
- }
- else
- {
- ARMARX_VERBOSE << "The LTM did not return data after query";
- result.memory = toIce<data::MemoryPtr>(wmResult);
+ // mark removed entries of wm in viewer
+ // TODO
+ }
}
+ result.memory = toIce<data::MemoryPtr>(wmResult);
+
result.success = true;
if (result.memory->coreSegments.size() == 0)
{
@@ -309,7 +335,8 @@ namespace armarx::armem::server
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(workingMemory);
- ARMARX_CHECK_NOT_NULL(longtermMemoryManager);
+ ARMARX_CHECK_NOT_NULL(longtermMemory);
+
data::StoreResult output;
for (const auto& query : input.query.memoryQueries)
@@ -326,7 +353,8 @@ namespace armarx::armem::server
{
armem::wm::Memory m;
fromIce(queryResult.memory, m);
- longtermMemoryManager->append(m);
+ longtermMemory->store(m);
+ longtermMemory->storeBuffer();
}
return output;
diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
index f924399c7eb749f8404f28c1c2a9bd7945112a7c..33e788ff566ca4f06b369160112f54160b425b46 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
@@ -4,7 +4,7 @@
#include <RobotAPI/interface/armem/client/MemoryListenerInterface.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
-#include <RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.h>
+#include <RobotAPI/libraries/armem/server/ltm/disk/Memory.h>
#include <RobotAPI/libraries/armem/client/Query.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
@@ -24,7 +24,7 @@ namespace armarx::armem::server
/// Construct an MemoryToIceAdapter from an existing Memory.
MemoryToIceAdapter(server::wm::Memory* workingMemory = nullptr,
- server::ltm::mongodb::MemoryManager* longtermMemory = nullptr);
+ server::ltm::disk::Memory* longtermMemory = nullptr);
void setMemoryListener(client::MemoryListenerInterfacePrx memoryListenerTopic);
@@ -55,7 +55,7 @@ namespace armarx::armem::server
public:
server::wm::Memory* workingMemory;
- server::ltm::mongodb::MemoryManager* longtermMemoryManager;
+ server::ltm::disk::Memory* longtermMemory;
client::MemoryListenerInterfacePrx memoryListenerTopic;
diff --git a/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.cpp b/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.cpp
index d2253746e591bcd18caabf997df25f9f0746fe5f..4ce73be809be81f4a3ccc6febcb75eb7b103a58d 100644
--- a/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.cpp
+++ b/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.cpp
@@ -14,9 +14,6 @@ namespace armarx::armem::server
groupBox.addChild(layout);
}
- RemoteGuiAronDataVisitor::~RemoteGuiAronDataVisitor()
- {}
-
bool RemoteGuiAronDataVisitor::visitEnter(const std::string& key, const std::string& type, size_t size)
{
std::stringstream label;
@@ -41,14 +38,14 @@ namespace armarx::armem::server
return true;
}
- void RemoteGuiAronDataVisitor::streamValueText(StringDataNavigator& n, std::stringstream& ss)
+ void RemoteGuiAronDataVisitor::streamValueText(aron::data::String& n, std::stringstream& ss)
{
ss << "'" << n.getValue() << "'";
}
- void RemoteGuiAronDataVisitor::streamValueText(NDArrayDataNavigator& n, std::stringstream& ss)
+ void RemoteGuiAronDataVisitor::streamValueText(aron::data::NDArray& n, std::stringstream& ss)
{
- ss << "shape (" << simox::alg::join(simox::alg::multi_to_string(n.getDimensions()), ", ") << ")";
+ ss << "shape (" << simox::alg::join(simox::alg::multi_to_string(n.getShape()), ", ") << ")";
}
void RemoteGuiAronDataVisitor::checkGroupsNotEmpty() const
diff --git a/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.h b/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.h
index 6149cbbc85faddd4ed8b51e33a73c3ae5f712875..081a5f9ef65857843e110017d3e491bd5f235801 100644
--- a/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.h
+++ b/source/RobotAPI/libraries/armem/server/RemoteGuiAronDataVisitor.h
@@ -5,13 +5,15 @@
#include <ArmarXGui/libraries/RemoteGui/Client/Widgets.h>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
namespace armarx::armem::server
{
- struct RemoteGuiAronDataVisitor : public aron::visitor::DataVisitor
+ struct RemoteGuiAronDataVisitor :
+ public aron::data::RecursiveConstVariantVisitor
{
using GroupBox = armarx::RemoteGui::Client::GroupBox;
using GridLayout = armarx::RemoteGui::Client::GridLayout;
@@ -31,78 +33,82 @@ namespace armarx::armem::server
GroupBox result;
- virtual ~RemoteGuiAronDataVisitor() override;
+ virtual ~RemoteGuiAronDataVisitor() = default;
-
- bool visitEnter(const std::string& key, DictDataNavigator& n) override
+ void visitDictOnEnter(const aron::data::VariantPtr& n) override
{
- return visitEnter(key, "dict", n.childrenSize());
+ ARMARX_CHECK_NOT_NULL(n);
+ const std::string key = n->getPath().getLastElement();
+ visitEnter(key, "dict", n->childrenSize());
}
- bool visitExit(DictDataNavigator&) override
+ void visitDictOnExit(const aron::data::VariantPtr&) override
{
- return visitExit();
+ visitExit();
}
- bool visitEnter(const std::string& key, ListDataNavigator& n) override
+ void visitListOnEnter(const aron::data::VariantPtr& n) override
{
- return visitEnter(key, "list", n.childrenSize());
+ ARMARX_CHECK_NOT_NULL(n);
+ const std::string key = n->getPath().getLastElement();
+ visitEnter(key, "list", n->childrenSize());
}
- bool visitExit(ListDataNavigator&) override
+ void visitListOnExit(const aron::data::VariantPtr&) override
{
- return visitExit();
+ visitExit();
}
// Same for Dict and List
bool visitEnter(const std::string& key, const std::string& type, size_t size);
bool visitExit();
- // Do not hide base overloads.
- using DataVisitor::visitEnter;
- using DataVisitor::visitExit;
-
-
- bool visit(const std::string& key, BoolDataNavigator& b) override
+ void visitBool(const aron::data::VariantPtr& b) override
{
- this->addValueLabel(key, b, "bool");
- return true;
+ ARMARX_CHECK_NOT_NULL(b);
+ const std::string key = b->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::Bool::DynamicCastAndCheck(b), "bool");
}
- bool visit(const std::string& key, DoubleDataNavigator& d) override
+ void visitDouble(const aron::data::VariantPtr& d) override
{
- this->addValueLabel(key, d, "double");
- return true;
+ ARMARX_CHECK_NOT_NULL(d);
+ const std::string key = d->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::Double::DynamicCastAndCheck(d), "double");
}
- bool visit(const std::string& key, FloatDataNavigator& f) override
+ void visitFloat(const aron::data::VariantPtr& f) override
{
- this->addValueLabel(key, f, "float");
- return true;
+ ARMARX_CHECK_NOT_NULL(f);
+ const std::string key = f->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::Float::DynamicCastAndCheck(f), "float");
}
- bool visit(const std::string& key, IntDataNavigator& i) override
+ void visitInt(const aron::data::VariantPtr& i) override
{
- this->addValueLabel(key, i, "int");
- return true;
+ ARMARX_CHECK_NOT_NULL(i);
+ const std::string key = i->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::Int::DynamicCastAndCheck(i), "int");
}
- bool visit(const std::string& key, LongDataNavigator& l) override
+ void visitLong(const aron::data::VariantPtr& l) override
{
- this->addValueLabel(key, l, "long");
- return true;
+ ARMARX_CHECK_NOT_NULL(l);
+ const std::string key = l->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::Long::DynamicCastAndCheck(l), "long");
}
- bool visit(const std::string& key, StringDataNavigator& string) override
+ void visitString(const aron::data::VariantPtr& string) override
{
- this->addValueLabel(key, string, "string");
- return true;
+ ARMARX_CHECK_NOT_NULL(string);
+ const std::string key = string->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::String::DynamicCastAndCheck(string), "string");
}
- bool visit(const std::string& key, NDArrayDataNavigator& array) override
+ void visitNDArray(const aron::data::VariantPtr& array) override
{
- this->addValueLabel(key, array, "ND Array");
- return true;
+ ARMARX_CHECK_NOT_NULL(array);
+ const std::string key = array->getPath().getLastElement();
+ this->addValueLabel(key, *aron::data::NDArray::DynamicCastAndCheck(array), "ND Array");
}
private:
-
- template <class Navigator>
- void addValueLabel(const std::string& key, Navigator& n, const std::string& typeName)
+ template <class DataT>
+ void addValueLabel(const std::string& key, DataT& n, const std::string& typeName)
{
checkGroupsNotEmpty();
Group& g = groups.top();
@@ -114,21 +120,21 @@ namespace armarx::armem::server
++g.nextRow;
}
- template <class Navigator>
- std::string getValueText(Navigator& n)
+ template <class DataT>
+ std::string getValueText(DataT& n)
{
std::stringstream ss;
streamValueText(n, ss);
return ss.str();
}
- template <class Navigator>
- void streamValueText(Navigator& n, std::stringstream& ss)
+ template <class DataT>
+ void streamValueText(DataT& n, std::stringstream& ss)
{
ss << n.getValue();
}
- void streamValueText(StringDataNavigator& n, std::stringstream& ss);
- void streamValueText(NDArrayDataNavigator& n, std::stringstream& ss);
+ void streamValueText(aron::data::String& n, std::stringstream& ss);
+ void streamValueText(aron::data::NDArray& n, std::stringstream& ss);
void checkGroupsNotEmpty() const;
diff --git a/source/RobotAPI/libraries/armem/server/forward_declarations.h b/source/RobotAPI/libraries/armem/server/forward_declarations.h
index d65ec0f36b9f60e680c6e720d80cd9cc3d6e789f..956a92b96ea8a75f7526fc5d111b0cc63bec26b8 100644
--- a/source/RobotAPI/libraries/armem/server/forward_declarations.h
+++ b/source/RobotAPI/libraries/armem/server/forward_declarations.h
@@ -18,5 +18,9 @@ namespace armarx::armem::server::wm
}
namespace armarx::armem::server::ltm::mongodb
{
- class MemoryManager;
+ class Memory;
+}
+namespace armarx::armem::server::ltm::disk
+{
+ class Memory;
}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.cpp
deleted file mode 100644
index 53e6f0169ab5ccb459ff730d67651836e78d5ec1..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.cpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#include "LongtermMemoryBase.h"
-
-#include <ArmarXCore/core/logging/Logging.h>
-#include <ArmarXCore/core/time/TimeUtil.h>
-
-#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-
-
-namespace armarx::armem::server::ltm
-{
- void
- LongtermMemoryBase::setName(const std::string& name)
- {
- cache.name() = name;
- lut.name() = name;
- }
-
-
- armem::wm::Memory
- LongtermMemoryBase::getCacheAndLutNotConverted() const
- {
- std::lock_guard l(cache_mutex);
- std::lock_guard l2(lut_mutex);
-
- armem::wm::Memory m(lut.name());
- m.append(cache);
- m.append(lut);
-
- // debug output
- //lut.forEachSnapshot([](const auto & e)
- //{
- // ARMARX_INFO << "The SNapshot: " << e.id().str() << " has size: " << e.size();
- //});
-
- return m;
- }
-
-
- template <class ...Args>
- void LongtermMemoryBase::_append(const armem::base::MemoryBase<Args...>& memory)
- {
- TIMING_START(LTM_Append);
- ARMARX_INFO << "Append memory with name '" << memory.name() << "' into the LTM with name '"
- << cache.name() << "'";
-
- std::lock_guard l(cache_mutex);
- cache.append(memory);
-
- encodeAndStore();
-
- TIMING_END(LTM_Append);
- }
-
-
- void
- LongtermMemoryBase::append(const armem::wm::Memory& memory)
- {
- this->_append(memory);
- }
-
-
- void
- LongtermMemoryBase::append(const armem::server::wm::Memory& memory)
- {
- this->_append(memory);
- }
-
-
- void
- LongtermMemoryBase::checkUpdateLatestSnapshot(const armem::wm::EntitySnapshot& newSnapshot)
- {
- // update map of latestSnapshots
- if (auto it = latestSnapshots.find(newSnapshot.id().getEntityID().str());
- it != latestSnapshots.end())
- {
- auto ptr = it->second;
- if (ptr->id().timestamp > newSnapshot.id().timestamp)
- {
- ptr = &newSnapshot;
- }
- // else ignore ==> no update
- }
- else
- {
- // no entry yet
- latestSnapshots.emplace(newSnapshot.id().getEntityID().str(), &newSnapshot);
- }
- }
-
-
- bool
- LongtermMemoryBase::containsCoreSegment(const MemoryID& coreSegmentID) const
- {
- //ARMARX_INFO << "Check if lut has core seg";
- if (lut.hasCoreSegment(coreSegmentID.coreSegmentName))
- {
- //ARMARX_INFO << "lus has core seg";
- return true;
- }
- return false;
- }
-
-
- bool
- LongtermMemoryBase::containsProviderSegment(const MemoryID& providerSegmentID) const
- {
- //ARMARX_INFO << "Check if lut has prov seg";
- if (lut.hasCoreSegment(providerSegmentID.coreSegmentName))
- {
- auto core = lut.getCoreSegment(providerSegmentID.coreSegmentName);
- if (core.hasProviderSegment(providerSegmentID.providerSegmentName))
- {
- //ARMARX_INFO << "lus has prov seg";
- return true;
- }
- }
- return false;
- }
-
-
- bool
- LongtermMemoryBase::containsEntity(const MemoryID& entityID) const
- {
- //ARMARX_INFO << "Check if lut has entity";
- if (lut.hasCoreSegment(entityID.coreSegmentName))
- {
- auto core = lut.getCoreSegment(entityID.coreSegmentName);
- if (core.hasProviderSegment(entityID.providerSegmentName))
- {
- auto prov = core.getProviderSegment(entityID.providerSegmentName);
- if (prov.hasEntity(entityID.entityName))
- {
- //ARMARX_INFO << "lus has entity";
- return true;
- }
- }
- }
- return false;
- }
-
-
- bool
- LongtermMemoryBase::containsSnapshot(const MemoryID& snapshotID) const
- {
- //ARMARX_INFO << "Check if lut has snapshot";
- if (lut.hasCoreSegment(snapshotID.coreSegmentName))
- {
- auto core = lut.getCoreSegment(snapshotID.coreSegmentName);
- if (core.hasProviderSegment(snapshotID.providerSegmentName))
- {
- auto prov = core.getProviderSegment(snapshotID.providerSegmentName);
- if (prov.hasEntity(snapshotID.entityName))
- {
- auto entity = prov.getEntity(snapshotID.entityName);
- if (entity.hasSnapshot(snapshotID.timestamp))
- {
- //ARMARX_INFO << "lut has snapshot";
- return true;
- }
- }
- }
- }
- return false;
- }
-
-} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.h
deleted file mode 100644
index 463c4c37998bd95ce4ec81f2e92eb0c937e2dc7c..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include <map>
-#include <mutex>
-#include <optional>
-#include <string>
-
-#include <RobotAPI/libraries/armem/core/MemoryID.h>
-#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
-#include <RobotAPI/libraries/armem/server/forward_declarations.h>
-
-
-namespace armarx::armem::server::ltm
-{
- /// @brief Interface functions for the longterm memory classes
- class LongtermMemoryBase
- {
- public:
- struct AppendResult
- {
- std::vector<MemoryID> addedCoreSegments;
- std::vector<MemoryID> addedProviderSegments;
- std::vector<MemoryID> addedEntities;
-
- std::vector<MemoryID> addedSnapshots;
- std::vector<MemoryID> replacedSnapshots;
- std::vector<MemoryID> ignoredSnapshots;
- };
-
- struct ReloadResult
- {
- };
-
- void append(const armem::wm::Memory& memory);
- void append(const armem::server::wm::Memory& memory);
-
- virtual void reload() = 0;
- virtual void convert(armem::wm::Memory&) = 0;
- virtual void encodeAndStore() = 0;
-
- // pass through to internal memory
- void setName(const std::string& name);
-
- // get merged internal memory
- armem::wm::Memory getCacheAndLutNotConverted() const;
-
- protected:
- void checkUpdateLatestSnapshot(const armem::wm::EntitySnapshot& newSnapshot);
-
- bool containsCoreSegment(const MemoryID&) const;
- bool containsProviderSegment(const MemoryID&) const;
- bool containsEntity(const MemoryID&) const;
- bool containsSnapshot(const MemoryID&) const;
-
- protected:
- /// Internal memory for data consolidated from wm to ltm (cache)
- armem::wm::Memory cache;
- mutable std::recursive_mutex cache_mutex;
-
- /// Internal memory for indexes (lut)
- armem::wm::Memory lut;
- mutable std::recursive_mutex lut_mutex;
-
- /// A map from entityID to its latest snapshot stored. When adding a new snapshot we compare it to the last one stored.
- std::map<std::string, const armem::wm::EntitySnapshot*> latestSnapshots;
-
-
- private:
-
- template <class ...Args>
- void _append(const armem::base::MemoryBase<Args...>& memory);
-
- };
-} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd719807eb069bcf62db065ed42bb649c38d225d
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.cpp
@@ -0,0 +1 @@
+#include "Converter.h"
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.h
new file mode 100644
index 0000000000000000000000000000000000000000..776b7c05ca15ba98c7350977c1fb4762e8e0a949
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.h
@@ -0,0 +1,35 @@
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+
+namespace armarx::armem::server::ltm
+{
+ class DictConverter;
+ using DictConverterPtr = std::shared_ptr<DictConverter>;
+
+ class DictConverter
+ {
+ public:
+ enum class ConverterType
+ {
+ Str,
+ Binary
+ };
+
+ DictConverter(const ConverterType t, const std::string& s):
+ type(t),
+ suffix(s)
+ {}
+ virtual ~DictConverter() = default;
+
+ virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) = 0;
+ virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) = 0;
+
+ const ConverterType type;
+ const std::string suffix;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e78913abd351657aaa73c852f7e336acd1c3c7f1
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.cpp
@@ -0,0 +1,35 @@
+#include "BsonConverter.h"
+
+#include <bsoncxx/json.hpp>
+#include <bsoncxx/builder/stream/helpers.hpp>
+#include <bsoncxx/builder/stream/document.hpp>
+#include <bsoncxx/builder/stream/array.hpp>
+
+namespace armarx::armem::server::ltm::converter::dict
+{
+ namespace bsoncxxbuilder = bsoncxx::builder::stream;
+ namespace bsoncxxdoc = bsoncxx::document;
+
+ std::vector<unsigned char> BsonConverter::convert(const aron::data::DictPtr& data)
+ {
+ std::vector<unsigned char> jsonVec = jsonConverter.convert(data);
+ std::string json(jsonVec.begin(), jsonVec.end());
+ auto view = bsoncxx::from_json(json).view();
+
+ std::vector<unsigned char> bson(view.length());
+ if (view.length() > 0)
+ {
+ std::memcpy(bson.data(), view.data(), view.length());
+ }
+ return bson;
+ }
+
+ aron::data::DictPtr BsonConverter::convert(const std::vector<unsigned char>& data)
+ {
+ bsoncxx::document::view view(data.data(), data.size());
+ nlohmann::json json = bsoncxx::to_json(view);
+ std::string str = json.dump(2);
+ std::vector<unsigned char> jsonVec(str.begin(), str.end());
+ return jsonConverter.convert(jsonVec);
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d6f858b0605edbe0496b279928b6cea6370e21c
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.h
@@ -0,0 +1,27 @@
+#pragma once
+
+// Base Class
+#include "../Converter.h"
+
+// ArmarX
+#include "../json/JsonConverter.h"
+
+namespace armarx::armem::server::ltm::converter::dict
+{
+ class BsonConverter;
+ using BsonConverterPtr = std::shared_ptr<BsonConverter>;
+
+ class BsonConverter : public DictConverter
+ {
+ public:
+ BsonConverter() :
+ DictConverter(ConverterType::Binary, ".bson")
+ {}
+
+ virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) override;
+ virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) override;
+
+ private:
+ JsonConverter jsonConverter;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..379caf9b76c45a997e7700a039290abe08726fd7
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.cpp
@@ -0,0 +1,20 @@
+#include "JsonConverter.h"
+
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+
+namespace armarx::armem::server::ltm::converter::dict
+{
+ std::vector<unsigned char> JsonConverter::convert(const aron::data::DictPtr& data)
+ {
+ nlohmann::json j = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(data);
+ auto str = j.dump(2);
+ return std::vector<unsigned char>(str.begin(), str.end());
+ }
+
+ aron::data::DictPtr JsonConverter::convert(const std::vector<unsigned char>& data)
+ {
+ std::string str(data.begin(), data.end());
+ nlohmann::json j = nlohmann::json::parse(str);
+ return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j);
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..fad44583f452740684724e45e47f74138c63697c
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.h
@@ -0,0 +1,24 @@
+#pragma once
+
+// Base Class
+#include "../Converter.h"
+
+// Simox
+#include <SimoxUtility/json.h>
+
+namespace armarx::armem::server::ltm::converter::dict
+{
+ class JsonConverter;
+ using JsonConverterPtr = std::shared_ptr<JsonConverter>;
+
+ class JsonConverter : public DictConverter
+ {
+ public:
+ JsonConverter() :
+ DictConverter(ConverterType::Str, ".json")
+ {}
+
+ virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) override;
+ virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd719807eb069bcf62db065ed42bb649c38d225d
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
@@ -0,0 +1 @@
+#include "Converter.h"
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
new file mode 100644
index 0000000000000000000000000000000000000000..740757ef84d98aa38ab1c2d65ab9e881bc215090
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
@@ -0,0 +1,35 @@
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
+
+namespace armarx::armem::server::ltm
+{
+ class ImageConverter;
+ using ImageConverterPtr = std::shared_ptr<ImageConverter>;
+
+ class ImageConverter
+ {
+ public:
+ enum class ConverterType
+ {
+ Str,
+ Binary
+ };
+
+ ImageConverter(const ConverterType t, const std::string& s):
+ type(t),
+ suffix(s)
+ {}
+ virtual ~ImageConverter() = default;
+
+ virtual std::vector<unsigned char> convert(const aron::data::NDArrayPtr& data) = 0;
+ virtual aron::data::NDArrayPtr convert(const std::vector<unsigned char>& data) = 0;
+
+ const ConverterType type;
+ const std::string suffix;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d513164c99cdc40c910f18da5843b8eac279b8f7
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
@@ -0,0 +1,27 @@
+#include "PngConverter.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h>
+
+#include <opencv2/opencv.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+
+
+namespace armarx::armem::server::ltm::converter::image
+{
+ std::vector<unsigned char> PngConverter::convert(const aron::data::NDArrayPtr& data)
+ {
+ ARMARX_CHECK_NOT_NULL(data);
+
+ auto img = aron::converter::AronOpenCVConverter::ConvertToMat(data);
+ std::vector<unsigned char> buffer;
+ cv::imencode(".png", img, buffer);
+ return buffer;
+ }
+
+ aron::data::NDArrayPtr PngConverter::convert(const std::vector<unsigned char>& data)
+ {
+ return {};
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..13581518a38a05a4ff1a2caaa8ddf7e25a8383af
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
@@ -0,0 +1,21 @@
+#pragma once
+
+// Base Class
+#include "../Converter.h"
+
+namespace armarx::armem::server::ltm::converter::image
+{
+ class PngConverter;
+ using PngConverterPtr = std::shared_ptr<PngConverter>;
+
+ class PngConverter : public ImageConverter
+ {
+ public:
+ PngConverter() :
+ ImageConverter(ConverterType::Str, ".png")
+ {}
+
+ virtual std::vector<unsigned char> convert(const aron::data::NDArrayPtr& data) override;
+ virtual aron::data::NDArrayPtr convert(const std::vector<unsigned char>& data) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..864266ce87d1e01a2f8eea0e0133a67ed14e7528
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.cpp
@@ -0,0 +1,7 @@
+#include "BufferedMemoryBase.h"
+
+namespace armarx::armem::server::ltm
+{
+
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..e03084a0bbba18ce9ee4866e5690fc3954808397
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "MemoryBase.h"
+
+namespace armarx::armem::server::ltm
+{
+ class BufferedMemoryItem
+ {
+ public:
+ BufferedMemoryItem() = default;
+ BufferedMemoryItem(const MemoryID& id) :
+ buffer(id)
+ {
+ }
+
+ virtual ~BufferedMemoryItem() = default;
+
+ armem::wm::Memory getBuffer() const
+ {
+ return buffer;
+ }
+
+ void directlyStore(const armem::wm::Memory& memory)
+ {
+ TIMING_START(LTM_Memory_DirectlyStore);
+ _directlyStore(memory);
+ TIMING_END(LTM_Memory_DirectlyStore);
+ }
+
+ void storeBuffer()
+ {
+ if (buffer.empty())
+ {
+ ARMARX_INFO << deactivateSpam() << "Cannot store an empty buffer. Ignoring.";
+ return;
+ }
+ this->directlyStore(buffer);
+ buffer.clear();
+ }
+
+ protected:
+ virtual void _directlyStore(const armem::wm::Memory& memory) = 0;
+
+ protected:
+
+ /// Internal memory for data consolidated from wm to ltm (buffer)
+ /// The to-put-to-ltm buffer (contains data in plain text)
+ /// This buffer may still be filtered.
+ /// This means that it is not guaranteed that all data in the buffer will be stored in the ltm
+ armem::wm::Memory buffer;
+
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cdeac54146741ac16c611098a57166b7316bb5e6
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.cpp
@@ -0,0 +1,6 @@
+#include "CoreSegmentBase.h"
+
+namespace armarx::armem::server::ltm
+{
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..47a6278ab7c98739e58675164d9b6b0a65431b6d
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/CoreSegmentBase.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <functional>
+
+// BaseClass
+#include "MemoryItem.h"
+
+#include "ProviderSegmentBase.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+
+namespace armarx::armem::server::ltm
+{
+ /// @brief Interface functions for the longterm memory classes
+ template <class _ProviderSegmentT>
+ class CoreSegmentBase : public MemoryItem
+ {
+ public:
+ using ProviderSegmentT = _ProviderSegmentT;
+
+ using MemoryItem::MemoryItem;
+
+ /// return the full sub-ltm as a wm::CoreSegment with only references
+ /// the ltm may be huge, use with caution
+ void loadAll(armem::wm::CoreSegment& coreSeg)
+ {
+ _loadAll(coreSeg);
+ }
+
+ /// convert the references of the input into a wm::Memory
+ void load(armem::wm::CoreSegment& coreSeg)
+ {
+ _load(coreSeg);
+ }
+
+ /// encode the content of a wm::Memory and store
+ void store(const armem::wm::CoreSegment& coreSeg)
+ {
+ _store(coreSeg);
+ }
+
+ /// iterate over all provider segments of this ltm
+ virtual bool forEachProviderSegment(std::function<void(ProviderSegmentT&)>&& func) const = 0;
+
+ /// find provider segment
+ virtual std::shared_ptr<ProviderSegmentT> findProviderSegment(const std::string&) const = 0;
+
+ /// get aron type
+ aron::type::ObjectPtr aronType() const
+ {
+ return nullptr;
+ }
+
+ /// get level name
+ static std::string getLevelName()
+ {
+ return "LT-CoreSegment";
+ }
+
+ protected:
+ virtual void _loadAll(armem::wm::CoreSegment&) = 0;
+ virtual void _load(armem::wm::CoreSegment&) = 0;
+ virtual void _store(const armem::wm::CoreSegment&) = 0;
+
+ protected:
+ mutable std::recursive_mutex ltm_mutex;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0f93fc4711a3dec9e1a2be658ab749134aa0013
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.cpp
@@ -0,0 +1,10 @@
+#include "EntityBase.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/time/TimeUtil.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+namespace armarx::armem::server::ltm
+{
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..38d3dec99173d19ccc00f9a8569f585cd700a27b
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntityBase.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <functional>
+
+// BaseClass
+#include "MemoryItem.h"
+
+#include "EntitySnapshotBase.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+
+namespace armarx::armem::server::ltm
+{
+ /// @brief Interface functions for the longterm memory classes
+ template <class _EntitySnapshotT>
+ class EntityBase : public MemoryItem
+ {
+ public:
+ using EntitySnapshotT = _EntitySnapshotT;
+
+ using MemoryItem::MemoryItem;
+
+ /// return the full sub-ltm as a wm::Entity with only references
+ /// the ltm may be huge, use with caution
+ void loadAll(armem::wm::Entity& e)
+ {
+ _loadAll(e);
+ }
+
+ /// convert the references of the input into a wm::Memory
+ void load(armem::wm::Entity& e)
+ {
+ _load(e);
+ }
+
+ /// encode the content of a wm::Memory and store
+ void store(const armem::wm::Entity& e)
+ {
+ _store(e);
+ }
+
+ /// iterate over all entity snapshots of this ltm
+ virtual bool forEachSnapshot(std::function<void(EntitySnapshotT&)>&& func) const = 0;
+ virtual bool forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshotT&)>&& func) const = 0;
+ virtual bool forEachSnapshotInTimeRange(const Time& min, const Time& max, std::function<void(EntitySnapshotT&)>&& func) const = 0;
+ virtual bool forEachSnapshotBeforeOrAt(const Time& time, std::function<void(EntitySnapshotT&)>&& func) const = 0;
+ virtual bool forEachSnapshotBefore(const Time& time, std::function<void(EntitySnapshotT&)>&& func) const = 0;
+
+ /// find entity snapshot segment
+ virtual std::shared_ptr<EntitySnapshotT> findSnapshot(const Time&) const = 0;
+ virtual std::shared_ptr<EntitySnapshotT> findLatestSnapshot() const = 0;
+ virtual std::shared_ptr<EntitySnapshotT> findLatestSnapshotBefore(const Time& time) const = 0;
+ virtual std::shared_ptr<EntitySnapshotT> findLatestSnapshotBeforeOrAt(const Time& time) const = 0;
+ virtual std::shared_ptr<EntitySnapshotT> findFirstSnapshotAfter(const Time& time) const = 0;
+ virtual std::shared_ptr<EntitySnapshotT> findFirstSnapshotAfterOrAt(const Time& time) const = 0;
+
+ static std::string getLevelName()
+ {
+ return "LT-Entity";
+ }
+
+ protected:
+ virtual void _loadAll(armem::wm::Entity&) = 0;
+ virtual void _load(armem::wm::Entity&) = 0;
+ virtual void _store(const armem::wm::Entity&) = 0;
+
+ protected:
+ mutable std::recursive_mutex ltm_mutex;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b053d008f1900e323628c5be5b2324be6d0eb22
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.cpp
@@ -0,0 +1,14 @@
+#include "EntitySnapshotBase.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/time/TimeUtil.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+namespace armarx::armem::server::ltm
+{
+ std::string EntitySnapshotBase::getLevelName()
+ {
+ return "LT-EntitySnapshot";
+ }
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7cd75f6801d7dfef1c397e8d9f81881c654c294
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/EntitySnapshotBase.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <functional>
+
+// BaseClass
+#include "MemoryItem.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+
+namespace armarx::armem::server::ltm
+{
+ /// @brief Interface functions for the longterm memory classes
+ class EntitySnapshotBase : public MemoryItem
+ {
+ public:
+
+ using MemoryItem::MemoryItem;
+
+ /// return the full sub-ltm as a wm::EntitySnapshot with only references
+ /// the ltm may be huge, use with caution
+ void loadAll(armem::wm::EntitySnapshot& e) const
+ {
+ _loadAll(e);
+ }
+
+ /// convert the references of the input into a wm::Memory
+ void load(armem::wm::EntitySnapshot& e) const
+ {
+ _load(e);
+ }
+
+ /// encode the content of a wm::Memory and store
+ void store(const armem::wm::EntitySnapshot& e) const
+ {
+ _store(e);
+ }
+
+ static std::string getLevelName();
+
+ protected:
+ virtual void _loadAll(armem::wm::EntitySnapshot&) const = 0;
+ virtual void _load(armem::wm::EntitySnapshot&) const = 0;
+ virtual void _store(const armem::wm::EntitySnapshot&) const = 0;
+
+ protected:
+ mutable std::recursive_mutex ltm_mutex;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1078e776d6ef68d2f7e102bff78676bb28d9b351
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.cpp
@@ -0,0 +1,6 @@
+#include "LUTMemoryBase.h"
+
+namespace armarx::armem::server::ltm
+{
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..597f4e3874764f6ac8c83b74efc6dab98534d27e
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/LUTMemoryBase.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "MemoryBase.h"
+
+namespace armarx::armem::server::ltm
+{
+ // TODO refactor to mixin (see buffered)
+ template <class _CoreSegmentT>
+ class CachedMemoryBase : virtual public MemoryBase<_CoreSegmentT>
+ {
+ public:
+ using MemoryBase<_CoreSegmentT>::MemoryBase;
+
+ armem::wm::Memory getCache() const
+ {
+ std::lock_guard l(this->ltm_mutex);
+ return cache;
+ }
+
+ void setMemoryID(const MemoryID& id) override
+ {
+ MemoryBase<_CoreSegmentT>::setMemoryID(id);
+ cache.name() = this->name();
+ }
+
+ protected:
+ static bool EntitySnapshotHasData(const armem::wm::EntitySnapshot& e)
+ {
+ // check whether all data is nullptr
+ bool allDataIsNull = e.size() > 0;
+ e.forEachInstance([&allDataIsNull](armem::wm::EntityInstance & e)
+ {
+ if (e.data())
+ {
+ allDataIsNull = false;
+ return false; // means break
+ }
+ return true;
+ });
+ return !allDataIsNull;
+ }
+
+ protected:
+
+ armem::wm::Memory cache;
+
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3375b372d2898297860403821447524b75e32830
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.cpp
@@ -0,0 +1,6 @@
+#include "MemoryBase.h"
+
+namespace armarx::armem::server::ltm
+{
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..8203fa4cd81936370a96784a37e219cdd5ed6748
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryBase.h
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <functional>
+
+// BaseClass
+#include "MemoryItem.h"
+
+// ChildType
+#include "CoreSegmentBase.h"
+
+// ArmarX
+#include <ArmarXCore/core/application/properties/Properties.h>
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/LoggingUtil.h>
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+#include <RobotAPI/libraries/armem/core/operations.h>
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+
+namespace armarx::armem::server::ltm
+{
+ /// @brief Interface functions for the longterm memory classes
+ template <class _CoreSegmentT>
+ class MemoryBase : public MemoryItem
+ {
+ public:
+ using CoreSegmentT = _CoreSegmentT;
+
+ using MemoryItem::MemoryItem;
+
+ /// return the full ltm as a wm::Memory with only references
+ /// the ltm may be huge, use with caution
+ void loadAll(armem::wm::Memory& memory)
+ {
+ TIMING_START(LTM_Memory_LoadAll);
+ _loadAll(memory);
+ TIMING_END(LTM_Memory_LoadAll);
+ }
+
+ /// convert the references of the input into a wm::Memory
+ void load(armem::wm::Memory& memory)
+ {
+ TIMING_START(LTM_Memory_Load);
+ _load(memory);
+ TIMING_END(LTM_Memory_Load);
+ }
+
+ /// append a wm::Memory instance to the ltm
+ void store(const armem::wm::Memory& memory)
+ {
+ TIMING_START(LTM_Memory_Append);
+ if (pipeline.memFilter->accept(memory))
+ {
+ _store(memory);
+ }
+ else
+ {
+ ARMARX_WARNING << deactivateSpam() << "Ignoring to put a Memory into the LTM because it got filtered.";
+ }
+ TIMING_END(LTM_Memory_Append);
+ }
+
+ /// append a wm::Memory instance to the ltm
+ void store(const armem::server::wm::Memory& serverMemory)
+ {
+ wm::Memory memory;
+ memory.update(armem::toCommit(serverMemory));
+ this->store(memory);
+ }
+
+ /// iterate over all core segments of this ltm
+ virtual bool forEachCoreSegment(std::function<void(CoreSegmentT&)>&& func) const = 0;
+
+ /// find core segment
+ virtual std::shared_ptr<CoreSegmentT> findCoreSegment(const std::string&) const = 0;
+
+ /// parameters
+ virtual void createPropertyDefinitions(PropertyDefinitionsPtr& properties, const std::string& prefix)
+ {}
+
+ /// get level name
+ static std::string getLevelName()
+ {
+ return "LT-Memory";
+ }
+
+ protected:
+ virtual void _loadAll(armem::wm::Memory& memory) = 0;
+ virtual void _load(armem::wm::Memory& memory) = 0;
+ virtual void _store(const armem::wm::Memory& memory) = 0;
+
+ public:
+ bool enabled = true;
+
+ protected:
+ mutable std::recursive_mutex ltm_mutex;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c932b5690f1ef5cd2f33dea87cf13b9381bfeed3
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.cpp
@@ -0,0 +1,35 @@
+#include "MemoryItem.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/time/TimeUtil.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+namespace armarx::armem::server::ltm
+{
+ MemoryItem::MemoryItem(const MemoryID& id) :
+ _id(id)
+ {
+ }
+
+ MemoryItem::MemoryItem(const MemoryID& id, const LongTermMemoryPipeline& p) :
+ pipeline(p),
+ _id(id)
+ {
+ }
+
+ void MemoryItem::setMemoryID(const MemoryID& id)
+ {
+ _id = id;
+ }
+
+ MemoryID MemoryItem::id() const
+ {
+ return _id;
+ }
+
+ std::string MemoryItem::name() const
+ {
+ return _id.getLeafItem();
+ }
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..e654dc887446b82a5d34dd7b08ff86c7ef874c04
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/MemoryItem.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <map>
+#include <mutex>
+#include <optional>
+#include <string>
+
+#include "../filter/Filter.h"
+#include "../extractor/Extractor.h"
+#include "../converter/dict/Converter.h"
+#include "../converter/image/Converter.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+
+namespace armarx::armem::server::ltm
+{
+ struct LongTermMemoryPipeline
+ {
+ MemoryFilterPtr memFilter;
+ SnapshotFilterPtr snapFilter;
+ DictConverterPtr dictConverter;
+ ImageConverterPtr imgConverter;
+ ExtractorPtr extractor;
+ };
+
+ /// @brief Interface functions for the longterm memory classes
+ class MemoryItem
+ {
+ public:
+ MemoryItem() = default;
+ MemoryItem(const MemoryID&);
+ MemoryItem(const MemoryID&, const LongTermMemoryPipeline&);
+ virtual ~MemoryItem() = default;
+
+ MemoryID id() const;
+ std::string name() const;
+
+ virtual void setMemoryID(const MemoryID&);
+
+ protected:
+ LongTermMemoryPipeline pipeline;
+
+ private:
+ MemoryID _id;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..15a2cc306660a0e09b6ea5ac6fd5ea53f678b650
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.cpp
@@ -0,0 +1,11 @@
+#include "ProviderSegmentBase.h"
+
+#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/time/TimeUtil.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+namespace armarx::armem::server::ltm
+{
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..167858dc748b5c8289bc62ab1ae12d4329c95a97
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/detail/ProviderSegmentBase.h
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <functional>
+
+// BaseClass
+#include "MemoryItem.h"
+
+#include "EntityBase.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+
+namespace armarx::armem::server::ltm
+{
+ /// @brief Interface functions for the longterm memory classes
+ template <class _EntityT>
+ class ProviderSegmentBase : public MemoryItem
+ {
+ public:
+ using EntityT = _EntityT;
+
+ using MemoryItem::MemoryItem;
+
+ /// return the full sub-ltm as a wm::ProviderSegment with only references
+ /// the ltm may be huge, use with caution
+ void loadAll(armem::wm::ProviderSegment& provSeg)
+ {
+ _loadAll(provSeg);
+ }
+
+ /// convert the references of the input into a wm::Memory
+ void load(armem::wm::ProviderSegment& provSeg)
+ {
+ _load(provSeg);
+ }
+
+ /// encode the content of a wm::Memory and store
+ void store(const armem::wm::ProviderSegment& provSeg)
+ {
+ _store(provSeg);
+ }
+
+ /// iterate over all core segments of this ltm
+ virtual bool forEachEntity(std::function<void(EntityT&)>&& func) const = 0;
+
+ /// find entity segment
+ virtual std::shared_ptr<EntityT> findEntity(const std::string&) const = 0;
+
+ aron::type::ObjectPtr aronType() const
+ {
+ return nullptr;
+ }
+
+ static std::string getLevelName()
+ {
+ return "LT-ProviderSegment";
+ }
+
+ protected:
+ virtual void _loadAll(armem::wm::ProviderSegment&) = 0;
+ virtual void _load(armem::wm::ProviderSegment&) = 0;
+ virtual void _store(const armem::wm::ProviderSegment&) = 0;
+
+ protected:
+ mutable std::recursive_mutex ltm_mutex;
+ };
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..57443153937c94fc7f218ec2ce427d7c5f45a7b5
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.cpp
@@ -0,0 +1 @@
+#include "Extractor.h"
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.h b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c3030f8987efeac2f81f8b5cc3ae2f59c81ef93
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.h
@@ -0,0 +1,32 @@
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
+
+namespace armarx::armem::server::ltm
+{
+ class Extractor;
+ typedef std::shared_ptr<Extractor> ExtractorPtr;
+
+ class Extractor
+ {
+ public:
+ struct Extraction
+ {
+ aron::data::DictPtr data;
+ std::map<std::string, aron::data::NDArrayPtr> images;
+ std::map<std::string, aron::data::NDArrayPtr> pointclouds;
+ std::map<std::string, aron::data::NDArrayPtr> matrices;
+ };
+
+ Extractor() = default;
+ virtual ~Extractor() = default;
+
+ virtual Extraction extract(aron::data::DictPtr& data) = 0;
+ virtual aron::data::DictPtr merge(Extraction& encoding) = 0;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a48b54ca4bb7f055c19f28eaf75d32d0dd50e7da
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.cpp
@@ -0,0 +1,48 @@
+#include "ImageExtractor.h"
+
+
+namespace armarx::armem::server::ltm::extractor
+{
+ void ImageExtractorVisitor::visitDictOnEnter(Input& data)
+ {
+ ARMARX_CHECK_NOT_NULL(data);
+
+ auto dict = aron::data::Dict::DynamicCastAndCheck(data);
+ for (const auto& [key, child] : dict->getElements())
+ {
+ if (child && child->getDescriptor() == aron::data::Descriptor::eNDArray)
+ {
+ auto ndarray = aron::data::NDArray::DynamicCastAndCheck(child);
+ auto shape = ndarray->getShape();
+ if (shape.size() == 3 && std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<int>()) > 200) // must be big enough to assume an image (instead of 4x4x4 poses)
+ {
+ images[key] = ndarray;
+ dict->setElement(key, nullptr);
+ }
+ }
+ }
+ }
+
+ void ImageExtractorVisitor::visitUnknown(Input& data)
+ {
+ // A member is null. Simply ignore...
+ }
+
+ Extractor::Extraction ImageExtractor::extract(aron::data::DictPtr& data)
+ {
+ ImageExtractorVisitor visitor;
+ aron::data::VariantPtr var = std::static_pointer_cast<aron::data::Variant>(data);
+ aron::data::VariantPtr p;
+ aron::data::visitRecursive(visitor, var);
+
+ Extraction encoding;
+ encoding.data = data;
+ encoding.images = visitor.images;
+ return encoding;
+ }
+
+ aron::data::DictPtr ImageExtractor::merge(Extraction& encoding)
+ {
+ return encoding.data;
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.h b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.h
new file mode 100644
index 0000000000000000000000000000000000000000..14c3fd4b7da1fe90f88b0106056aee265d8b5cd9
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.h
@@ -0,0 +1,30 @@
+#pragma once
+
+// Base Class
+#include "../Extractor.h"
+
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
+
+namespace armarx::armem::server::ltm::extractor
+{
+ class ImageExtractor;
+ typedef std::shared_ptr<ImageExtractor> ImageExtractorPtr;
+
+ class ImageExtractorVisitor : public aron::data::RecursiveVariantVisitor
+ {
+ public:
+ std::map<std::string, aron::data::NDArrayPtr> images;
+
+ void visitDictOnEnter(Input& data);
+ void visitUnknown(Input& data);
+ };
+
+ class ImageExtractor : public Extractor
+ {
+ public:
+ ImageExtractor() = default;
+
+ virtual Extraction extract(aron::data::DictPtr& data) override;
+ virtual aron::data::DictPtr merge(Extraction& encoding) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0d446f7f72a31b526481734980cd7bb07da4c92
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.cpp
@@ -0,0 +1,17 @@
+#include "NoExtractor.h"
+
+
+namespace armarx::armem::server::ltm::extractor
+{
+ Extractor::Extraction NoExtractor::extract(aron::data::DictPtr& data)
+ {
+ Extraction encoding;
+ encoding.data = data;
+ return encoding;
+ }
+
+ aron::data::DictPtr NoExtractor::merge(Extraction& encoding)
+ {
+ return encoding.data;
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.h b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdcc6668471815f8a8c645e19a002adb60275beb
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.h
@@ -0,0 +1,19 @@
+#pragma once
+
+// Base Class
+#include "../Extractor.h"
+
+namespace armarx::armem::server::ltm::extractor
+{
+ class NoExtractor;
+ typedef std::shared_ptr<NoExtractor> NoExtractorPtr;
+
+ class NoExtractor : public Extractor
+ {
+ public:
+ NoExtractor() = default;
+
+ virtual Extraction extract(aron::data::DictPtr& data) override;
+ virtual aron::data::DictPtr merge(Extraction& encoding) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..088af9712ebf2e93637acfa5ec982e05e9cfd66e
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.cpp
@@ -0,0 +1,2 @@
+#include "Filter.h"
+
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.h b/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5b068600ac0bb1a89215d81861c2a7a0e10bc6f
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.h
@@ -0,0 +1,35 @@
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// ArmarX
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
+
+namespace armarx::armem::server::ltm
+{
+ class SnapshotFilter;
+ typedef std::shared_ptr<SnapshotFilter> SnapshotFilterPtr;
+
+ class MemoryFilter;
+ typedef std::shared_ptr<MemoryFilter> MemoryFilterPtr;
+
+ class MemoryFilter
+ {
+ public:
+ MemoryFilter() = default;
+ virtual ~MemoryFilter() = default;
+
+ virtual bool accept(const armem::wm::Memory& e) = 0;
+ };
+
+ class SnapshotFilter
+ {
+ public:
+ SnapshotFilter() = default;
+ virtual ~SnapshotFilter() = default;
+
+ virtual bool accept(const armem::wm::EntitySnapshot& e) = 0;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5650c836523a90c48d5cfb50b9b9e6ef8b307af9
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.cpp
@@ -0,0 +1,39 @@
+#include "FrequencyFilter.h"
+
+#include <IceUtil/Time.h>
+
+namespace armarx::armem::server::ltm::filter
+{
+ bool MemoryFrequencyFilter::accept(const armem::wm::Memory& e)
+ {
+ auto now = armem::Time::now().toMilliSeconds();
+ if (waitingTimeInMs < 0 || (now - timestampLastCommitInMs) > waitingTimeInMs)
+ {
+ timestampLastCommitInMs = now;
+ return true;
+ }
+ return false;
+ }
+
+ bool SnapshotFrequencyFilter::accept(const armem::wm::EntitySnapshot& e)
+ {
+ auto entityID = e.id().getEntityID();
+ auto genMs = e.time().toMilliSeconds();
+
+ long lastMs = 0;
+ if (timestampLastCommitInMs.count(entityID) > 0)
+ {
+ lastMs = timestampLastCommitInMs.at(entityID);
+ }
+
+ if (waitingTimeInMs < 0 || (genMs - lastMs) > waitingTimeInMs)
+ {
+ /*std::cout << "diff: " << (dataGeneratedInMs - timestampLastCommitInMs) << std::endl;
+ std::cout << "gen: " << (dataGeneratedInMs) << std::endl;
+ std::cout << "last: " << (timestampLastCommitInMs) << std::endl;*/
+ timestampLastCommitInMs[entityID] = genMs;
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.h b/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.h
new file mode 100644
index 0000000000000000000000000000000000000000..a791f862abed1b14e9bf75eb3046a635a8d77c36
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.h
@@ -0,0 +1,39 @@
+#pragma once
+
+// Base Class
+#include "../Filter.h"
+
+namespace armarx::armem::server::ltm::filter
+{
+ class SnapshotFrequencyFilter;
+ typedef std::shared_ptr<SnapshotFrequencyFilter> SnapshotFrequencyFilterPtr;
+
+ class MemoryFrequencyFilter;
+ typedef std::shared_ptr<MemoryFrequencyFilter> MemoryFrequencyFilterPtr;
+
+ class MemoryFrequencyFilter :
+ public MemoryFilter
+ {
+ public:
+ MemoryFrequencyFilter() = default;
+
+ virtual bool accept(const armem::wm::Memory& e) override;
+
+ private:
+ int waitingTimeInMs = -1;
+ long timestampLastCommitInMs = 0;
+ };
+
+ class SnapshotFrequencyFilter :
+ public SnapshotFilter
+ {
+ public:
+ SnapshotFrequencyFilter() = default;
+
+ virtual bool accept(const armem::wm::EntitySnapshot& e) override;
+
+ private:
+ int waitingTimeInMs = 1000;
+ std::unordered_map<MemoryID, long> timestampLastCommitInMs;
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/Forgetter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/Forgetter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/Forgetter.h b/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/Forgetter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/LRUForgetter/LRUForgetter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/LRUForgetter/LRUForgetter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/LRUForgetter/LRUForgetter.h b/source/RobotAPI/libraries/armem/server/ltm/base/forgetter/LRUForgetter/LRUForgetter.h
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c78baf87f70dbc88c8ab8e00c4174a5b9e019c2f
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
@@ -0,0 +1,101 @@
+#include "CoreSegment.h"
+
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+
+namespace armarx::armem::server::ltm::disk
+{
+ namespace
+ {
+ MemoryID getMemoryIDFromPath(const std::filesystem::path& p)
+ {
+ util::ensureFolderExists(p);
+
+ MemoryID m;
+ m.memoryName = p.parent_path().filename();
+ m.coreSegmentName = p.filename();
+ return m;
+ }
+ }
+
+ CoreSegment::CoreSegment(const std::filesystem::path& p, const LongTermMemoryPipeline& pipe) :
+ CoreSegmentBase(getMemoryIDFromPath(p), pipe),
+ DiskMemoryItem(p)
+ {
+ }
+
+ bool CoreSegment::forEachProviderSegment(std::function<void(ProviderSegment&)>&& func) const
+ {
+ if (!checkPath())
+ {
+ return false;
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ for (const auto& subdir : std::filesystem::directory_iterator(p))
+ {
+ std::filesystem::path subdirPath = subdir.path();
+ ProviderSegment c(subdirPath, pipeline);
+ func(c);
+ }
+ return true;
+ }
+
+ std::shared_ptr<ProviderSegment> CoreSegment::findProviderSegment(const std::string& n) const
+ {
+ if (!checkPath())
+ {
+ return {};
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ std::filesystem::path subpath = p / n;
+ util::ensureFolderExists(subpath, false);
+ auto c = std::make_shared<ProviderSegment>(subpath, pipeline);
+ return c;
+ }
+
+ std::string CoreSegment::getExpectedFolderName() const
+ {
+ return name();
+ }
+
+ void CoreSegment::_loadAll(armem::wm::CoreSegment& e)
+ {
+ e.id() = id();
+
+ forEachProviderSegment([&e](ProviderSegment& x) {
+ armem::wm::ProviderSegment s;
+ x.loadAll(s);
+ e.addProviderSegment(s);
+ });
+ }
+
+ void CoreSegment::_load(armem::wm::CoreSegment& c)
+ {
+ c.forEachProviderSegment([this](armem::wm::ProviderSegment& e)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / e.id().providerSegmentName, false);
+ ProviderSegment c((std::filesystem::path(path) / e.id().providerSegmentName), pipeline);
+ c.load(e);
+ });
+ }
+
+ void CoreSegment::_store(const armem::wm::CoreSegment& c)
+ {
+ c.forEachProviderSegment([this](const auto& provSegment)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / provSegment.id().providerSegmentName);
+ ProviderSegment c((std::filesystem::path(path) / provSegment.id().providerSegmentName), pipeline);
+ c.store(provSegment);
+ });
+ }
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.h b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5d5d6c59a89482f7ebc5b779826737a062542d1
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <filesystem>
+
+// Base Class
+#include "../base/detail/CoreSegmentBase.h"
+#include "detail/DiskStorage.h"
+
+#include "ProviderSegment.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ class CoreSegment :
+ public CoreSegmentBase<ProviderSegment>,
+ public DiskMemoryItem
+ {
+ public:
+
+ CoreSegment(const std::filesystem::path&, const LongTermMemoryPipeline& p);
+
+ bool forEachProviderSegment(std::function<void(ProviderSegment&)>&& func) const override;
+
+ std::shared_ptr<ProviderSegment> findProviderSegment(const std::string&) const override;
+
+ protected:
+ void _loadAll(armem::wm::CoreSegment&) override;
+ void _load(armem::wm::CoreSegment&) override;
+ void _store(const armem::wm::CoreSegment&) override;
+
+ std::string getExpectedFolderName() const override;
+
+ };
+
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4beead8cacdd373bb40268d0f9919d042aa40339
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
@@ -0,0 +1,159 @@
+// Header
+#include "Entity.h"
+
+// ArmarX
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+#include "../base/filter/frequencyFilter/FrequencyFilter.h"
+
+
+namespace armarx::armem::server::ltm::disk
+{
+
+ namespace
+ {
+ MemoryID getMemoryIDFromPath(const std::filesystem::path& p)
+ {
+ util::ensureFolderExists(p);
+
+ MemoryID m;
+ m.memoryName = p.parent_path().parent_path().parent_path().filename();
+ m.coreSegmentName = p.parent_path().parent_path().filename();
+ m.providerSegmentName = p.parent_path().filename();
+ m.entityName = p.filename();
+ return m;
+ }
+ }
+
+ Entity::Entity(const std::filesystem::path& p, const LongTermMemoryPipeline& pipe) :
+ EntityBase(getMemoryIDFromPath(p), pipe),
+ DiskMemoryItem(p)
+ {
+ }
+
+ std::string Entity::getExpectedFolderName() const
+ {
+ return name();
+ }
+
+ bool Entity::forEachSnapshot(std::function<void(EntitySnapshot&)>&& func) const
+ {
+ if (!checkPath())
+ {
+ return false;
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ for (const auto& subdir : std::filesystem::directory_iterator(p))
+ {
+ std::filesystem::path subdirPath = subdir.path();
+ EntitySnapshot c(subdirPath, pipeline);
+ func(c);
+ }
+ return true;
+ }
+
+ bool Entity::forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)>&& func) const
+ {
+ return true;
+ }
+
+ bool Entity::forEachSnapshotInTimeRange(const Time& min, const Time& max, std::function<void(EntitySnapshot&)>&& func) const
+ {
+ return true;
+ }
+
+ bool Entity::forEachSnapshotBeforeOrAt(const Time& time, std::function<void(EntitySnapshot&)>&& func) const
+ {
+ return true;
+ }
+
+ bool Entity::forEachSnapshotBefore(const Time& time, std::function<void(EntitySnapshot&)>&& func) const
+ {
+ return true;
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findSnapshot(const Time& n) const
+ {
+ if (!checkPath())
+ {
+ return {};
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ std::filesystem::path subpath = p / std::to_string(n.toMicroSeconds());
+ util::ensureFolderExists(subpath, false);
+ auto c = std::make_shared<EntitySnapshot>(subpath, pipeline);
+ return c;
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findLatestSnapshot() const
+ {
+ return {};
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findLatestSnapshotBefore(const Time& time) const
+ {
+ return {};
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findLatestSnapshotBeforeOrAt(const Time& time) const
+ {
+ return {};
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findFirstSnapshotAfter(const Time& time) const
+ {
+ return {};
+ }
+
+ std::shared_ptr<EntitySnapshot> Entity::findFirstSnapshotAfterOrAt(const Time& time) const
+ {
+ return {};
+ }
+
+ void Entity::_loadAll(armem::wm::Entity& e)
+ {
+ e.id() = id();
+
+ forEachSnapshot([&e](EntitySnapshotBase& x) {
+ armem::wm::EntitySnapshot s;
+ x.loadAll(s);
+ e.addSnapshot(s);
+ });
+ }
+
+ void Entity::_load(armem::wm::Entity& p)
+ {
+ p.forEachSnapshot([this](armem::wm::EntitySnapshot& e)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / std::to_string(e.id().timestamp.toMicroSeconds()), false);
+ EntitySnapshot c((std::filesystem::path(path) / std::to_string(e.id().timestamp.toMicroSeconds())), pipeline);
+ c.load(e);
+ });
+ }
+
+ void Entity::_store(const armem::wm::Entity& entity)
+ {
+ entity.forEachSnapshot([this](armem::wm::EntitySnapshot& e)
+ {
+ if (!pipeline.snapFilter->accept(e))
+ {
+ ARMARX_WARNING << deactivateSpam() << "Ignoring to put an EntitiySnapshot into the LTM because it got filtered.";
+ return;
+ }
+
+ util::ensureFolderExists(std::filesystem::path(path) / std::to_string(e.id().timestamp.toMicroSeconds()));
+ EntitySnapshot c((std::filesystem::path(path) / std::to_string(e.id().timestamp.toMicroSeconds())), pipeline);
+ c.store(e);
+ });
+ }
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.h b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e0414339218e4d58173597004fecb36c899f059
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <filesystem>
+
+// Base Class
+#include "../base/detail/EntityBase.h"
+#include "detail/DiskStorage.h"
+
+#include "EntitySnapshot.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ /// @brief A memory storing data in mongodb (needs 'armarx memory start' to start the mongod instance)
+ class Entity :
+ public EntityBase<EntitySnapshot>,
+ public DiskMemoryItem
+ {
+ public:
+ Entity(const std::filesystem::path&, const LongTermMemoryPipeline& p);
+
+ bool forEachSnapshot(std::function<void(EntitySnapshot&)>&& func) const override;
+ bool forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)>&& func) const override;
+ bool forEachSnapshotInTimeRange(const Time& min, const Time& max, std::function<void(EntitySnapshot&)>&& func) const override;
+ bool forEachSnapshotBeforeOrAt(const Time& time, std::function<void(EntitySnapshot&)>&& func) const override;
+ bool forEachSnapshotBefore(const Time& time, std::function<void(EntitySnapshot&)>&& func) const override;
+
+ std::shared_ptr<EntitySnapshot> findSnapshot(const Time&) const override;
+ std::shared_ptr<EntitySnapshot> findLatestSnapshot() const override;
+ std::shared_ptr<EntitySnapshot> findLatestSnapshotBefore(const Time& time) const override;
+ std::shared_ptr<EntitySnapshot> findLatestSnapshotBeforeOrAt(const Time& time) const override;
+ std::shared_ptr<EntitySnapshot> findFirstSnapshotAfter(const Time& time) const override;
+ std::shared_ptr<EntitySnapshot> findFirstSnapshotAfterOrAt(const Time& time) const override;
+
+ protected:
+ void _loadAll(armem::wm::Entity&) override;
+ void _load(armem::wm::Entity&) override;
+ void _store(const armem::wm::Entity&) override;
+
+ std::string getExpectedFolderName() const override;
+
+ };
+
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..94cbec5482e924f32cf34490e66f1d037badf351
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
@@ -0,0 +1,145 @@
+// Header
+#include "EntitySnapshot.h"
+
+// STD / STL
+#include <iostream>
+#include <fstream>
+
+// ArmarX
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+
+namespace armarx::armem::server::ltm::disk
+{
+
+ namespace
+ {
+ MemoryID getMemoryIDFromPath(const std::filesystem::path& p)
+ {
+ util::ensureFolderExists(p);
+
+ MemoryID m;
+ m.memoryName = p.parent_path().parent_path().parent_path().parent_path().filename();
+ m.coreSegmentName = p.parent_path().parent_path().parent_path().filename();
+ m.providerSegmentName = p.parent_path().parent_path().filename();
+ m.entityName = p.parent_path().filename();
+ m.timestamp = IceUtil::Time::microSeconds(std::stol(p.filename()));
+ return m;
+ }
+
+ void writeDataToFile(const std::filesystem::path& path, const std::vector<unsigned char>& data)
+ {
+ std::ofstream dataofs;
+ dataofs.open(path);
+ dataofs.write(reinterpret_cast<const char*>(data.data()), data.size());
+ dataofs.close();
+ }
+ }
+
+ EntitySnapshot::EntitySnapshot(const std::filesystem::path& p, const LongTermMemoryPipeline& pipe) :
+ EntitySnapshotBase(getMemoryIDFromPath(p), pipe),
+ DiskMemoryItem(p)
+ {
+
+ }
+
+ std::string EntitySnapshot::getExpectedFolderName() const
+ {
+ return name();
+ }
+
+ void EntitySnapshot::_loadAll(armem::wm::EntitySnapshot& e) const
+ {
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ e.id() = id();
+
+ for (unsigned int i = 0; i < 1000; ++i) // 1000 is max size for instances in a single timestamp
+ {
+ if (!util::checkIfFolderExists(p / std::to_string(i)))
+ {
+ break;
+ }
+
+ // add instance. Do not set data, since we only return references
+ e.addInstance();
+ }
+ }
+
+ void EntitySnapshot::_load(armem::wm::EntitySnapshot& e) const
+ {
+ // Get data from disk
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ for (unsigned int i = 0; i < e.size(); ++i)
+ {
+ util::ensureFolderExists(p / std::to_string(i), false);
+
+ std::filesystem::path data = p / std::to_string(i) / (constantes::DATA_FILENAME + pipeline.dictConverter->suffix);
+ std::filesystem::path metadata = p / std::to_string(i) / (constantes::METADATA_FILENAME + pipeline.dictConverter->suffix);
+
+ util::ensureFileExists(data);
+
+ auto& ins = e.getInstance(i);
+
+ std::ifstream dataifs(data);
+ std::vector<unsigned char> datafilecontent((std::istreambuf_iterator<char>(dataifs)), (std::istreambuf_iterator<char>()));
+ auto dataaron = pipeline.dictConverter->convert(datafilecontent);
+
+ std::ifstream metadataifs(metadata);
+ std::vector<unsigned char> metadatafilecontent((std::istreambuf_iterator<char>(metadataifs)), (std::istreambuf_iterator<char>()));
+ auto metadataaron = pipeline.dictConverter->convert(metadatafilecontent);
+
+ from_aron(metadataaron, dataaron, ins);
+ }
+ }
+
+ void EntitySnapshot::_store(const armem::wm::EntitySnapshot& e) const
+ {
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p);
+
+ for (unsigned int i = 0; i < e.size(); ++i)
+ {
+ std::filesystem::path instancePath = p / std::to_string(i);
+ util::ensureFolderExists(instancePath);
+
+ std::filesystem::path dataPath = instancePath / (constantes::DATA_FILENAME + pipeline.dictConverter->suffix);
+ std::filesystem::path metadataPath = instancePath / (constantes::METADATA_FILENAME + pipeline.dictConverter->suffix);
+
+ if (util::checkIfFileExists(dataPath) or util::checkIfFileExists(metadataPath))
+ {
+ continue;
+ }
+
+ auto& ins = e.getInstance(i);
+
+ // data
+ auto dataAron = std::make_shared<aron::data::Dict>();
+ auto metadataAron = std::make_shared<aron::data::Dict>();
+ to_aron(metadataAron, dataAron, ins);
+
+ // extract
+ auto dataExt = pipeline.extractor->extract(dataAron);
+ auto metadataExt = pipeline.extractor->extract(metadataAron);
+
+ // convert images
+ for (const auto& [memberName, img] : dataExt.images)
+ {
+ ARMARX_CHECK_NOT_NULL(img);
+ std::filesystem::path imgPath = instancePath / (memberName + pipeline.imgConverter->suffix);
+ auto imgVec = pipeline.imgConverter->convert(img);
+ writeDataToFile(imgPath, imgVec);
+ }
+
+ // convert dict and metadata
+ auto dataVec = pipeline.dictConverter->convert(dataExt.data);
+ auto metadataVec = pipeline.dictConverter->convert(metadataExt.data);
+ writeDataToFile(dataPath, dataVec);
+ writeDataToFile(metadataPath, metadataVec);
+ }
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h
new file mode 100644
index 0000000000000000000000000000000000000000..690d948251099033b453d37f0d72a89cc3df5e80
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <filesystem>
+
+// Base Class
+#include "../base/detail/EntitySnapshotBase.h"
+#include "detail/DiskStorage.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+
+ class EntitySnapshot :
+ public EntitySnapshotBase,
+ public DiskMemoryItem
+ {
+ public:
+ EntitySnapshot(const std::filesystem::path&, const LongTermMemoryPipeline& p);
+
+ protected:
+ void _loadAll(armem::wm::EntitySnapshot&) const override;
+ void _load(armem::wm::EntitySnapshot&) const override;
+ void _store(const armem::wm::EntitySnapshot&) const override;
+
+ std::string getExpectedFolderName() const override;
+
+ };
+
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8797b7cd6c730ce999d59084db011af8a0d169d1
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
@@ -0,0 +1,171 @@
+#include "Memory.h"
+
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+// ArmarX
+#include "../base/filter/frequencyFilter/FrequencyFilter.h"
+#include "../base/extractor/noExtractor/NoExtractor.h"
+#include "../base/extractor/imageExtractor/ImageExtractor.h"
+#include "../base/converter/dict/json/JsonConverter.h"
+#include "../base/converter/dict/bson/BsonConverter.h"
+#include "../base/converter/image/png/PngConverter.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ namespace
+ {
+ MemoryID getMemoryIDFromPath(const std::filesystem::path& p)
+ {
+ ARMARX_CHECK(!p.empty());
+
+ util::ensureFolderExists(p);
+
+ MemoryID m;
+ m.memoryName = p.filename();
+ return m;
+ }
+
+ std::filesystem::path getDefaultStoragePath()
+ {
+ /*std::string armarx_home = std::string(getenv("HOME")) + "/.armarx";
+ if (getenv("ARMARX_DEFAULTS_DIR"))
+ {
+ armarx_home = getenv("ARMARX_DEFAULTS_DIR");
+ }
+ path = armarx_home + "/armem/disk/data/db";*/
+ return "/tmp/MemoryExport/Test";
+ }
+ }
+
+ void Memory::createPropertyDefinitions(PropertyDefinitionsPtr& properties, const std::string& prefix)
+ {
+ properties->optional(path, prefix + "storagepath", "The path to the memory storage.");
+ }
+
+ Memory::Memory() :
+ Memory(getDefaultStoragePath())
+ {
+ }
+
+ Memory::Memory(const std::filesystem::path& p) :
+ Base(getMemoryIDFromPath(p)),
+ BufferedMemoryItem(getMemoryIDFromPath(p)),
+ DiskMemoryItem(p)
+ {
+ pipeline.memFilter = std::make_shared<filter::MemoryFrequencyFilter>();
+ pipeline.snapFilter = std::make_shared<filter::SnapshotFrequencyFilter>();
+ pipeline.extractor = std::make_shared<extractor::ImageExtractor>();
+ pipeline.dictConverter = std::make_shared<converter::dict::JsonConverter>();
+ pipeline.imgConverter = std::make_shared<converter::image::PngConverter>();
+ }
+
+ void Memory::setMemoryID(const MemoryID& id)
+ {
+ ARMARX_CHECK_NOT_EMPTY(id.memoryName);
+
+ Base::setMemoryID(id.getMemoryID());
+ std::filesystem::path p(path);
+ path = (p.parent_path() / id.memoryName);
+ buffer.id() = id.getMemoryID();
+ }
+
+ std::string Memory::getExpectedFolderName() const
+ {
+ return id().memoryName;
+ }
+
+ bool Memory::forEachCoreSegment(std::function<void(CoreSegment&)>&& func) const
+ {
+ if (!checkPath())
+ {
+ return false;
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ for (const auto& subdir : std::filesystem::directory_iterator(p))
+ {
+ std::filesystem::path subdirPath = subdir.path();
+ CoreSegment c(subdirPath, pipeline);
+ func(c);
+ }
+ return true;
+ }
+
+ std::shared_ptr<CoreSegment> Memory::findCoreSegment(const std::string& n) const
+ {
+ if (!checkPath())
+ {
+ return {};
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ std::filesystem::path subpath = p / n;
+ util::ensureFolderExists(subpath, false);
+ auto c = std::make_shared<CoreSegment>(subpath, pipeline);
+ return c;
+ }
+
+ void Memory::_loadAll(armem::wm::Memory& m)
+ {
+ m.id() = id();
+
+ forEachCoreSegment([&m](CoreSegment& x) {
+ armem::wm::CoreSegment s;
+ x.loadAll(s);
+ m.addCoreSegment(s);
+ });
+ }
+
+ void Memory::_load(armem::wm::Memory& m)
+ {
+ if (!checkPath())
+ {
+ return;
+ }
+
+ std::lock_guard l(ltm_mutex);
+ m.forEachCoreSegment([this](armem::wm::CoreSegment& e)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / e.id().coreSegmentName, false);
+ CoreSegment c((std::filesystem::path(path) / e.id().coreSegmentName), pipeline);
+ c.load(e);
+ });
+ }
+
+ void Memory::_store(const armem::wm::Memory& memory)
+ {
+ std::lock_guard l(this->ltm_mutex);
+ buffer.append(memory);
+ }
+
+ void Memory::_directlyStore(const armem::wm::Memory& memory)
+ {
+ if (!this->pipeline.memFilter->accept(memory))
+ {
+ ARMARX_WARNING << deactivateSpam() << "Ignoring to put a Memory into the LTM because it got filtered.";
+ return;
+ }
+
+ if (!checkPath())
+ {
+ return;
+ }
+
+ std::lock_guard l(ltm_mutex);
+
+ memory.forEachCoreSegment([this](const auto& core)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / core.id().coreSegmentName);
+ CoreSegment c((std::filesystem::path(path) / core.id().coreSegmentName), pipeline);
+ c.store(core);
+ });
+ }
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.h b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..aae36c9324da269e1a4e23a25905d3413e9f6be8
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <filesystem>
+
+// Base Class
+#include <RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h>
+#include "detail/DiskStorage.h"
+
+// Segmnet Type
+#include "CoreSegment.h"
+
+
+namespace armarx::armem::server::ltm::disk
+{
+ /// @brief A memory storing data in mongodb (needs 'armarx memory start' to start the mongod instance)
+ class Memory :
+ public MemoryBase<CoreSegment>,
+ public BufferedMemoryItem,
+ public DiskMemoryItem
+ {
+ public:
+ using Base = MemoryBase<CoreSegment>;
+
+ Memory();
+ Memory(const std::filesystem::path&);
+
+ void setMemoryID(const MemoryID& id) override;
+
+ void createPropertyDefinitions(PropertyDefinitionsPtr& properties, const std::string& prefix) override;
+
+ bool forEachCoreSegment(std::function<void(CoreSegment&)>&& func) const override;
+
+ std::shared_ptr<CoreSegment> findCoreSegment(const std::string&) const override;
+
+ protected:
+ void _loadAll(armem::wm::Memory&) override;
+ void _load(armem::wm::Memory&) override;
+ void _store(const armem::wm::Memory&) override;
+ void _directlyStore(const armem::wm::Memory&) override;
+
+ std::string getExpectedFolderName() const override;
+
+ };
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.cpp
deleted file mode 100644
index b2360b5c6580ea37bbbbb6765817e998e910c302..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-// Header
-#include "MemoryManager.h"
-
-// STD / STL
-#include <iostream>
-#include <fstream>
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// ArmarX
-#include <ArmarXCore/core/time/TimeUtil.h>
-#include <ArmarXCore/core/logging/Logging.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
-#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
-
-namespace
-{
- // check whether a string is a number (timestamp folders)
- bool isNumber(const std::string& s)
- {
- for (char const& ch : s)
- {
- if (std::isdigit(ch) == 0)
- {
- return false;
- }
- }
- return true;
- }
-}
-
-namespace armarx::armem::server::ltm::disk
-{
- namespace fs = std::filesystem;
-
- bool MemoryManager::checkPath() const
- {
- // Check connection:
- ARMARX_INFO << "Checking Path";
- if (!fs::exists(basePathToMemory) || !fs::is_directory(basePathToMemory) || basePathToMemory.filename() != lut.name())
- {
- ARMARX_WARNING << deactivateSpam("PathIsNotValid")
- << "The entered path is not valid. Please use a path leading to a memory folder with name: " << lut.name() << "."
- << "\n\n";
- return false;
- }
-
- return true;
- }
-
- void MemoryManager::reload()
- {
- TIMING_START(LTM_Reload);
- ARMARX_INFO << "(Re)Loading a memory from: " << basePathToMemory.string();
-
- if (!checkPath())
- {
- // abort
- ARMARX_WARNING << "Could not (pre)load a memory from the filesystem.";
- return;
- }
-
- armem::wm::Memory temp(lut.id()); // a temporary client wm. We will append temp to the lut at the end of this metho (append ignores duplicate entries)
- ARMARX_INFO << "Loading memory: " << temp.id().str();
-
- // ///////////////////////////////
- // Iterate over core segments
- // ///////////////////////////////
- for (const auto& d : std::filesystem::directory_iterator(basePathToMemory))
- // Although this looks like code duplication, we need a distinguition between memories,
- // core, prov and entities because of a different structure
- // (only core and prov have same structure)
- {
-
- if (!d.is_directory())
- {
- continue;
- }
-
- std::string k = d.path().filename();
- if (temp.hasCoreSegment(k))
- {
- throw error::ArMemError("Somehow the (memory) container already contains the key k = " + k + ". This should not happen.");
- }
-
- // ///////////////////////////////
- // Add and iterate over core segments
- // ///////////////////////////////
- auto& cSeg = temp.addCoreSegment(k);
- for (const auto& d : std::filesystem::directory_iterator(d))
- {
- if (!d.is_directory())
- {
- continue;
- }
-
- std::string k = d.path().filename();
- if (cSeg.hasProviderSegment(k))
- {
- throw error::ArMemError("Somehow the (core) container already contains the key k = " + k + ". This should not happen.");
- }
-
- // ///////////////////////////////
- // Add and iterate over provider segments
- // ///////////////////////////////
- auto& pSeg = cSeg.addProviderSegment(k);
- for (const auto& d : std::filesystem::directory_iterator(d))
- {
- if (!d.is_directory())
- {
- continue;
- }
-
- std::string k = d.path().filename();
- if (pSeg.hasEntity(k))
- {
- throw error::ArMemError("Somehow the (provider) container already contains the key k = " + k + ". This should not happen.");
- }
-
- // ///////////////////////////////
- // Add and iterate over entities
- // ///////////////////////////////
- auto& eSeg = pSeg.addEntity(k);
- for (const auto& d : std::filesystem::directory_iterator(d))
- {
- if (!d.is_directory())
- {
- continue;
- }
-
- std::string k = d.path().filename();
- if (!isNumber(k))
- {
- continue;
- }
-
- auto ts = armem::Time::microSeconds(std::stol(k));
- // TODO catch exceptions?
-
- if (eSeg.hasSnapshot(ts))
- {
- throw error::ArMemError("Somehow the (entity) container already contains the key k = " + k + ". This should not happen.");
- }
-
- // ///////////////////////////////
- // Add and iterate over entities
- // ///////////////////////////////
- auto& sSeg = eSeg.addSnapshot(ts);
- for (unsigned int i = 0; i < 10000; ++i) // ugly workaround to get the folders in the correct order
- {
- fs::path p = d / std::to_string(i);
- if (!fs::exists(p) || !fs::is_directory(p))
- {
- // early stopping
- break;
- }
-
- fs::path data = p / DATA_FILENAME;
- if (!fs::exists(data) || !fs::is_regular_file(data))
- {
- // do not set data
- continue;
- }
-
- // else we have an instance
- /*std::ifstream ifs(data);
- std::string file_content((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
-
- nlohmann::json j = nlohmann::json::parse(file_content);
- auto aron = aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSON(j);*/
-
- sSeg.addInstance();
- //from_aron(aron, instance);
- }
- }
- }
- }
- }
-
- std::lock_guard l(cache_mutex); // we always take the cache mutex BEFORE the lut mutex! (otherwise we may have deadlocks)
- std::lock_guard l2(lut_mutex);
- lut.append(temp);
- ARMARX_INFO << "After reload memory " << lut.id().str() << " has size: " << lut.size();
-
- TIMING_END(LTM_Reload);
- }
-
- void MemoryManager::convert(armem::wm::Memory& m)
- {
- TIMING_START(LTM_Convert);
- if (!checkPath())
- {
- // abort
- ARMARX_WARNING << "Could not convert a memory from the filesystem.";
- return;
- }
-
- // update emtpy data ptr
- m.forEachCoreSegment([this](armem::wm::CoreSegment & e)
- {
- e.forEachProviderSegment([this](armem::wm::ProviderSegment & e)
- {
- e.forEachEntity([this](armem::wm::Entity & e)
- {
- e.forEachSnapshot([this](armem::wm::EntitySnapshot & e)
- {
- // check whether data is nullptr
- bool allDataIsNull = e.size() > 0;
- e.forEachInstance([&allDataIsNull](armem::wm::EntityInstance & e)
- {
- if (e.data())
- {
- allDataIsNull = false;
- return false; // means break
- }
- return true;
- });
-
- if (allDataIsNull) // an entry from the lut (probably... for now we assume that every entry either has data (cache) or has null (lut))
- {
- // Get data from mongodb
- auto p = basePathToMemory / e.id().coreSegmentName / e.id().providerSegmentName / e.id().entityName / std::to_string(e.id().timestamp.toMicroSeconds());
-
- if (fs::exists(p) && fs::is_directory(p))
- {
- for (unsigned int i = 0; i < e.size(); ++i)
- {
- auto data = p / std::to_string(i) / DATA_FILENAME;
-
- if (fs::exists(data) && fs::is_regular_file(data))
- {
- auto& ins = e.getInstance(i);
-
- std::ifstream ifs(data);
- std::string file_content((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
- nlohmann::json doc = nlohmann::json::parse(file_content);
-
- auto aron = aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSON(doc);
-
- wm::EntityInstance tmp(e.id().withInstanceIndex(i));
- from_aron(aron, tmp);
-
- ins.data() = tmp.data();
- }
- }
- }
- // else leave snapshot untouched
- }
- });
- });
- });
- });
- TIMING_END(LTM_Convert);
- }
-
- void MemoryManager::encodeAndStore()
- {
- TIMING_START(LTM_Encode);
- if (!checkPath())
- {
- // abort
- ARMARX_WARNING << "Could not (pre)load a memory from the filesystem.";
- return;
- }
-
- std::lock_guard l(cache_mutex);
-
- // ///////////////////////////////
- // Iterate over core segments
- // ///////////////////////////////
- fs::path mPath = basePathToMemory;
- cache.forEachCoreSegment([&mPath](armem::wm::CoreSegment & e)
- {
- fs::path cPath = mPath / e.id().coreSegmentName;
- if (!fs::exists(cPath))
- {
- // not found
- fs::create_directory(cPath);
- }
- if (!fs::is_directory(cPath))
- {
- throw error::ArMemError("Could not create the (core) folder: " + cPath.string());
- }
-
- // ///////////////////////////////
- // Iterate over provider segments
- // ///////////////////////////////
- e.forEachProviderSegment([&cPath](armem::wm::ProviderSegment & e)
- {
- fs::path pPath = cPath / e.id().providerSegmentName;
- if (!fs::exists(pPath))
- {
- // not found
- fs::create_directory(pPath);
- }
- if (!fs::is_directory(pPath))
- {
- throw error::ArMemError("Could not create the (provider) folder: " + pPath.string());
- }
-
- // ///////////////////////////////
- // Iterate over entities
- // ///////////////////////////////
- e.forEachEntity([&pPath](armem::wm::Entity & e)
- {
- fs::path ePath = pPath / e.id().entityName;
- if (!fs::exists(ePath))
- {
- // not found
- fs::create_directory(ePath);
- }
- if (!fs::is_directory(ePath))
- {
- throw error::ArMemError("Could not create the (entity) folder: " + ePath.string());
- }
-
- // ///////////////////////////////
- // Iterate over snapshots
- // ///////////////////////////////
- e.forEachSnapshot([&ePath](armem::wm::EntitySnapshot & e)
- {
- fs::path sPath = ePath / std::to_string(e.id().timestamp.toMicroSeconds());
- if (!fs::exists(sPath))
- {
- // not found
- fs::create_directory(sPath);
- }
- else
- {
- ARMARX_INFO << "The snapshot " << sPath.string() << " already exists. Ingoring it.";
- return; // continue if already exists
- }
-
- if (!fs::is_directory(sPath))
- {
- throw error::ArMemError("Could not create the (timestamp) folder: " + sPath.string());
- }
-
- // ///////////////////////////////
- // Iterate over instances
- // ///////////////////////////////
- e.forEachInstance([&sPath](armem::wm::EntityInstance & e)
- {
- fs::path iPath = sPath / std::to_string(e.id().instanceIndex);
- if (!fs::exists(iPath))
- {
- // not found
- fs::create_directory(iPath);
- }
- else
- {
- // This is strange, since we know, that the snapshot folder did not exist.
- // However, we ignore and continue
- ARMARX_INFO << "Somehow the instance folder " << iPath.string() << " already exists, although the snapshot folder was newly created. Ignore this.";
- return;
- }
- if (!fs::is_directory(iPath))
- {
- throw error::ArMemError("Could not create the (instance) folder: " + iPath.string());
- }
-
- fs::path data = iPath / DATA_FILENAME;
- if (fs::exists(data))
- {
- // Should not be the case. Anyway, if it happens, create new file!
- fs::remove(data);
- }
-
- std::ofstream ofs;
- ofs.open(data);
-
- auto aron = std::make_shared<aron::datanavigator::DictNavigator>();
- to_aron(aron, e);
- nlohmann::json j = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(aron);
-
- ofs << j.dump(2);
- ofs.close();
- });
- });
- });
- });
-
- });
-
- // what to do with clear text data after encoding?
- // TODO!
-
- // Finaly clear cache and put reference to lut
- cache.forEachInstance([](armem::wm::EntityInstance & i)
- {
- i.data() = nullptr;
- });
-
- std::lock_guard l2(lut_mutex);
- lut.append(cache);
- cache.clear();
-
- TIMING_END(LTM_Encode);
- }
-}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.h b/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.h
deleted file mode 100644
index e9eeffb05667a7e4feeb9c638abea41be02201cd..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <mutex>
-#include <optional>
-
-#include <RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.h>
-
-
-namespace armarx::armem::server::ltm::disk
-{
- /// @brief A memory storing data in mongodb (needs 'armarx memory start' to start the mongod instance)
- class MemoryManager : public LongtermMemoryBase
- {
- using Base = LongtermMemoryBase;
-
- public:
- MemoryManager() = default;
-
- void reload() override;
- void convert(armem::wm::Memory&) override;
- void encodeAndStore() override;
-
- void
- setBasePath(const std::filesystem::path& p)
- {
- basePathToMemory = p;
- }
-
- protected:
- private:
- bool checkPath() const;
-
- public:
- std::filesystem::path basePathToMemory;
-
- private:
- static const constexpr char* TYPE_FILENAME = "type.aron.ltm.json";
- static const constexpr char* DATA_FILENAME = "data.aron.ltm.json";
- };
-
-} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5eeb70355107afee9d8979c2d11b872839c9f4cd
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
@@ -0,0 +1,103 @@
+// Header
+#include "ProviderSegment.h"
+
+// ArmarX
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
+
+
+namespace armarx::armem::server::ltm::disk
+{
+ namespace
+ {
+ MemoryID getMemoryIDFromPath(const std::filesystem::path& p)
+ {
+ util::ensureFolderExists(p);
+
+ MemoryID m;
+ m.memoryName = p.parent_path().parent_path().filename();
+ m.coreSegmentName = p.parent_path().filename();
+ m.providerSegmentName = p.filename();
+ return m;
+ }
+ }
+
+ ProviderSegment::ProviderSegment(const std::filesystem::path& p, const LongTermMemoryPipeline& pipe) :
+ ProviderSegmentBase(getMemoryIDFromPath(p), pipe),
+ DiskMemoryItem(p)
+ {
+ }
+
+ bool ProviderSegment::forEachEntity(std::function<void(Entity&)>&& func) const
+ {
+ if (!checkPath())
+ {
+ return false;
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ for (const auto& subdir : std::filesystem::directory_iterator(p))
+ {
+ std::filesystem::path subdirPath = subdir.path();
+ Entity c(subdirPath, pipeline);
+ func(c);
+ }
+ return true;
+ }
+
+ std::shared_ptr<Entity> ProviderSegment::findEntity(const std::string& n) const
+ {
+ if (!checkPath())
+ {
+ return {};
+ }
+
+ std::filesystem::path p = path;
+ util::ensureFolderExists(p, false);
+
+ std::filesystem::path subpath = p / n;
+ util::ensureFolderExists(subpath, false);
+ auto c = std::make_shared<Entity>(subpath, pipeline);
+ return c;
+ }
+
+ std::string ProviderSegment::getExpectedFolderName() const
+ {
+ return name();
+ }
+
+ void ProviderSegment::_loadAll(armem::wm::ProviderSegment& e)
+ {
+ e.id() = id();
+
+ forEachEntity([&e](Entity& x) {
+ armem::wm::Entity s;
+ x.loadAll(s);
+ e.addEntity(s);
+ });
+ }
+
+ void ProviderSegment::_load(armem::wm::ProviderSegment& p)
+ {
+ p.forEachEntity([this](armem::wm::Entity& e)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / e.id().entityName, false);
+ Entity c((std::filesystem::path(path) / e.id().entityName), pipeline);
+ c.load(e);
+ });
+ }
+
+ void ProviderSegment::_store(const armem::wm::ProviderSegment& providerSegment)
+ {
+ providerSegment.forEachEntity([this](const auto& entity)
+ {
+ util::ensureFolderExists(std::filesystem::path(path) / entity.id().entityName);
+ Entity c((std::filesystem::path(path) / entity.id().entityName), pipeline);
+ c.store(entity);
+ });
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.h b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.h
new file mode 100644
index 0000000000000000000000000000000000000000..9683715ef66b94d46a95e6e7c102fad7621561b5
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <filesystem>
+
+// Base Class
+#include "../base/detail/ProviderSegmentBase.h"
+#include "detail/DiskStorage.h"
+
+#include "Entity.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ class ProviderSegment :
+ public ProviderSegmentBase<Entity>,
+ public DiskMemoryItem
+ {
+ public:
+ ProviderSegment(const std::filesystem::path&, const LongTermMemoryPipeline& p);
+
+ bool forEachEntity(std::function<void(Entity&)>&& func) const override;
+
+ std::shared_ptr<Entity> findEntity(const std::string&) const override;
+
+ protected:
+ void _loadAll(armem::wm::ProviderSegment&) override;
+ void _load(armem::wm::ProviderSegment&) override;
+ void _store(const armem::wm::ProviderSegment&) override;
+
+ std::string getExpectedFolderName() const override;
+
+ };
+
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6eef0874de238366f4946cff7bb673b4b1f16c6
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.cpp
@@ -0,0 +1,7 @@
+// Header
+#include "Data.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.h b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.h
new file mode 100644
index 0000000000000000000000000000000000000000..6adbf12e2941fd9c298186b7c0d896923464403e
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/Data.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <filesystem>
+
+#include "../../../../core/error.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ namespace constantes
+ {
+ const std::string TYPE_FILENAME = "type.aron";
+ const std::string DATA_FILENAME = "data.aron";
+ const std::string METADATA_FILENAME = "metadata.aron";
+ }
+
+ namespace util
+ {
+ // check whether a string is a number (e.g. timestamp folders)
+ inline bool isNumber(const std::string& s)
+ {
+ for (char const& ch : s)
+ {
+ if (std::isdigit(ch) == 0)
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ inline bool checkIfFolderExists(const std::filesystem::path& p)
+ {
+ return std::filesystem::exists(p) and std::filesystem::is_directory(p);
+ }
+
+ inline void ensureFolderExists(const std::filesystem::path& p, bool createIfNotExistent = true)
+ {
+ if (!std::filesystem::exists(p))
+ {
+ if (createIfNotExistent)
+ {
+ std::filesystem::create_directory(p);
+ }
+ }
+ if (!std::filesystem::is_directory(p))
+ {
+ throw error::ArMemError("Could not find folder: " + p.string());
+ }
+ }
+
+ inline bool checkIfFileExists(const std::filesystem::path& p)
+ {
+ return std::filesystem::exists(p) and std::filesystem::is_regular_file(p);
+ }
+
+ inline void ensureFileExists(const std::filesystem::path& p)
+ {
+ if (!std::filesystem::exists(p) || !std::filesystem::is_regular_file(p))
+ {
+ // not found
+ throw error::ArMemError("Could not find file: " + p.string());
+ }
+ }
+ }
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb11ba7960184ed45669ea5b4e121f749a01683a
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.cpp
@@ -0,0 +1,45 @@
+// Header
+#include "DiskStorage.h"
+
+// ArmarX
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+namespace armarx::armem::server::ltm::disk
+{
+ DiskMemoryItem::DiskMemoryItem(const std::filesystem::path& p) :
+ path(p.string())
+ {
+ }
+
+ bool DiskMemoryItem::checkPath() const
+ {
+ std::filesystem::path memoryP(path);
+
+ // Check connection:
+ if (!std::filesystem::exists(path))
+ {
+ std::filesystem::create_directories(path);
+ return true;
+ }
+ else if (std::string expectedFolderName = getExpectedFolderName(); !std::filesystem::is_directory(path) || memoryP.filename() != expectedFolderName)
+ {
+ ARMARX_WARNING << deactivateSpam("LTM_PathError_" + expectedFolderName)
+ << "The entered path is not valid. Please use a path leading to a memory folder with name: " << expectedFolderName << ". The used path was: " << getPath()
+ << "\n\n";
+ return false;
+ }
+
+ return true;
+ }
+
+ std::string DiskMemoryItem::getPath() const
+ {
+ return path;
+ }
+
+ void DiskMemoryItem::setPath(const std::string& p)
+ {
+ path = p;
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.h b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbe803e94974da15de765f2a5cb6c29b8815831b
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/detail/DiskStorage.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <filesystem>
+
+#include "Data.h"
+
+namespace armarx::armem::server::ltm::disk
+{
+ class DiskMemoryItem
+ {
+ public:
+ DiskMemoryItem() = default;
+ DiskMemoryItem(const std::filesystem::path&);
+ virtual ~DiskMemoryItem() = default;
+
+ void setPath(const std::string&);
+ std::string getPath() const;
+
+ protected:
+ bool checkPath() const;
+ virtual std::string getExpectedFolderName() const = 0;
+
+ protected:
+ std::string path;
+ };
+} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/operations.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/operations.cpp
deleted file mode 100644
index 83d2b379d85225e6e369e8711c04ef068e5016e0..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/operations.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "operations.h"
-
-#include <RobotAPI/libraries/armem/client/query/Builder.h>
-#include <RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.h>
-#include <RobotAPI/libraries/armem/server/query_proc/ltm.h>
-#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-
-
-namespace armarx::armem::server::ltm
-{
-
- armem::wm::Memory
- disk::load(const std::filesystem::path& directory)
- {
- const std::string key = directory.filename();
- armem::server::ltm::disk::MemoryManager manager;
- manager.setName(key);
- manager.setBasePath(directory);
- manager.reload();
-
- armem::client::QueryBuilder builder;
- builder.all();
- armem::client::QueryInput queryInput = builder.buildQueryInput();
- queryInput.addQueryTargetToAll(armem::query::data::QueryTarget::LTM);
-
- armem::server::query_proc::ltm::MemoryQueryProcessor processor;
- armem::wm::Memory memory =
- processor.process(queryInput.toIce(), manager.getCacheAndLutNotConverted());
- manager.convert(memory);
-
- return memory;
- }
-
-
- namespace detail
- {
- template <class MemoryT>
- void
- store(const std::filesystem::path& directory, const MemoryT& memory)
- {
- const std::string& name = memory.name();
- if (std::filesystem::is_regular_file(directory / name))
- {
- std::stringstream ss;
- ss << "Could not export memory '" << name << "' to " << directory << ": "
- << "Cannot overwrite existing file.\n";
- throw error::IOError(directory, ss.str());
- }
- else
- {
- std::filesystem::create_directories(directory / name);
-
- armem::server::ltm::disk::MemoryManager manager;
- manager.setName(name);
- manager.setBasePath(directory / name);
- manager.reload();
- manager.append(memory);
- }
- }
- } // namespace detail
-
-
- void
- disk::store(const std::filesystem::path& directory, const armem::wm::Memory& memory)
- {
- detail::store(directory, memory);
- }
-
-
- void
- disk::store(const std::filesystem::path& directory, const armem::server::wm::Memory& memory)
- {
- detail::store(directory, memory);
- }
-
-} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/operations.h b/source/RobotAPI/libraries/armem/server/ltm/disk/operations.h
deleted file mode 100644
index b18575996f0ba38b0251844b5b9f18a2c98d0752..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/operations.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <filesystem>
-
-#include <RobotAPI/libraries/armem/core/forward_declarations.h>
-#include <RobotAPI/libraries/armem/server/forward_declarations.h>
-
-
-namespace armarx::armem::server::ltm::disk
-{
-
- armem::wm::Memory load(const std::filesystem::path& directory);
-
- void store(const std::filesystem::path& directory, const armem::wm::Memory& memory);
- void store(const std::filesystem::path& directory, const armem::server::wm::Memory& memory);
-
-
-} // namespace armarx::armem::server::ltm::disk
diff --git a/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.cpp b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..11414c6a21e518a17b7bb1e2925ba60efbf65dfe
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.cpp
@@ -0,0 +1,161 @@
+#include "ConnectionManager.h"
+
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+
+namespace armarx::armem::server::ltm::mongodb
+{
+ std::mutex ConnectionManager::initializationMutex;
+ bool ConnectionManager::initialized = false;
+ std::map<std::string, std::unique_ptr<mongocxx::pool>> ConnectionManager::Connections = {};
+
+ ConnectionManager::MongoDBSettings::MongoDBSettings()
+ {
+ std::string armarx_home = std::string(getenv("HOME")) + "/.armarx";
+ if (getenv("ARMARX_DEFAULTS_DIR"))
+ {
+ armarx_home = getenv("ARMARX_DEFAULTS_DIR");
+ }
+ std::ifstream cFile (armarx_home + "/default.cfg");
+ if (cFile.is_open())
+ {
+ std::string line;
+ while(getline(cFile, line))
+ {
+ line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());
+ if(line[0] == '#' || line.empty())
+ {
+ continue;
+ }
+ auto delimiterPos = line.find("=");
+ const auto name = line.substr(0, delimiterPos);
+ const auto value = line.substr(delimiterPos + 1);
+ if (name == "ArmarX.MongoHost")
+ {
+ host = value;
+ }
+ if (name == "ArmarX.MongoPort")
+ {
+ port = (unsigned int) std::stoi(value);
+ }
+ if (name == "ArmarX.MongoUser")
+ {
+ user = value;
+ }
+ if (name == "ArmarX.MongoPassword")
+ {
+ password = value;
+ }
+ }
+ }
+ }
+
+ bool ConnectionManager::MongoDBSettings::isSet() const
+ {
+ // we always need a host and a port
+ return !host.empty() and port != 0;
+ }
+
+ std::string ConnectionManager::MongoDBSettings::baseUri() const
+ {
+ std::stringstream ss;
+ ss << "mongodb://";
+
+ if (!user.empty())
+ {
+ ss << user;
+ if (!password.empty())
+ {
+ ss << ":" << password;
+ }
+ ss << "@";
+ }
+ ss << host;
+ return ss.str();
+ }
+
+ std::string ConnectionManager::MongoDBSettings::key() const
+ {
+ // TODO: What happens if a connection exists and you would like to open another one with a different user (e.g. that sees different things)?
+ return "mongodb://" + host + ":" + std::to_string(port);
+ }
+
+ std::string ConnectionManager::MongoDBSettings::uri() const
+ {
+ return baseUri() + ":" + std::to_string(port) + "/?minPoolSize=" + std::to_string(minPoolSize) + "&maxPoolSize=" + std::to_string(maxPoolSize);
+ }
+
+ std::string ConnectionManager::MongoDBSettings::toString() const
+ {
+ return uri() + "&database=" + database;
+ }
+
+ void ConnectionManager::initialize_if()
+ {
+ std::lock_guard l(initializationMutex); // all others have to wait until the initialization is complete
+ if (!initialized)
+ {
+ initialized = true;
+ mongocxx::instance instance{}; // This should be done only once.
+ }
+ }
+
+ mongocxx::pool& ConnectionManager::Connect(const MongoDBSettings& settings)
+ {
+ initialize_if();
+
+ const auto uri_str = settings.uri();
+ auto it = Connections.find(uri_str);
+ if (it == Connections.end())
+ {
+ mongocxx::uri uri(uri_str);
+ auto pool = std::make_unique<mongocxx::pool>(uri);
+ auto con = Connections.emplace(settings.key(), std::move(pool));
+ return *con.first->second;
+ }
+ else
+ {
+ // A connection already exists. We do not need to open another one.
+ return *it->second;
+ }
+ }
+
+ bool ConnectionManager::ConnectionIsValid(const MongoDBSettings& settings, bool forceNewConnection)
+ {
+ initialize_if();
+
+ try
+ {
+ if (!forceNewConnection)
+ {
+ auto it = Connections.find(settings.key());
+ if (it != Connections.end())
+ {
+ auto client = it->second->acquire();
+ auto admin = client->database("admin");
+ auto result = admin.run_command(bsoncxx::builder::basic::make_document(bsoncxx::builder::basic::kvp("isMaster", 1)));
+ return true;
+ }
+ }
+
+ mongocxx::uri uri(settings.uri());
+ auto client = mongocxx::client(uri);
+ auto admin = client["admin"];
+ auto result = admin.run_command(bsoncxx::builder::basic::make_document(bsoncxx::builder::basic::kvp("isMaster", 1)));
+ return true;
+ }
+ catch (const std::exception& xcp)
+ {
+ return false;
+ }
+ }
+
+ bool ConnectionManager::ConnectionExists(const MongoDBSettings& settings)
+ {
+ initialize_if();
+
+ auto it = Connections.find(settings.key());
+ return it != Connections.end();
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.h b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.h
similarity index 50%
rename from source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.h
rename to source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.h
index 15fac008d7963c034ce40fe55a4606ffe3fead3f..51acb7a0c7848b944beef878b969f54d5c141f1a 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/ConnectionManager.h
@@ -28,56 +28,29 @@ namespace armarx::armem::server::ltm::mongodb
class ConnectionManager
{
public:
+ ConnectionManager() = delete;
+
struct MongoDBSettings
{
- std::string host = "localhost";
- unsigned int port = 25276;
+ std::string host = "";
+ unsigned int port = 0;
std::string user = "";
std::string password = "";
std::string database = "Test";
int minPoolSize = 5;
int maxPoolSize = 100;
+ MongoDBSettings();
+
+ bool isSet() const;
+
+ std::string baseUri() const;
+
+ std::string key() const;
+
+ std::string uri() const;
- bool isSet() const
- {
- // we always need a host and a port
- return !host.empty() and port != 0;
- }
-
- std::string baseUri() const
- {
- std::stringstream ss;
- ss << "mongodb://";
-
- if (!user.empty())
- {
- ss << user;
- if (!password.empty())
- {
- ss << ":" << password;
- }
- ss << "@";
- }
- ss << host;
- return ss.str();
- }
-
- std::string key() const
- {
- // TODO: What happens if a connection exists and you would like to open another one with a different user (e.g. that sees different things)?
- return "mongodb://" + host + ":" + std::to_string(port);
- }
-
- std::string uri() const
- {
- return baseUri() + ":" + std::to_string(port) + "/?minPoolSize=" + std::to_string(minPoolSize) + "&maxPoolSize=" + std::to_string(maxPoolSize);
- }
-
- std::string toString() const
- {
- return uri() + "&database=" + database;
- }
+ std::string toString() const;
};
static mongocxx::pool& Connect(const MongoDBSettings& settings);
diff --git a/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.cpp b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2381297ee3a8311497b175c09372d6776cd1bf3b
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.cpp
@@ -0,0 +1,112 @@
+// Header
+#include "MemoryManager.h"
+
+// Simox
+#include <SimoxUtility/json.h>
+
+// ArmarX
+#include <ArmarXCore/core/time/TimeUtil.h>
+#include <ArmarXCore/core/logging/Logging.h>
+
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+
+#include "operations.h"
+
+namespace armarx::armem::server::ltm::mongodb
+{
+ namespace bsoncxxbuilder = bsoncxx::builder::stream;
+ namespace bsoncxxdoc = bsoncxx::document;
+
+ PoolClientPtr Memory::checkConnection() const
+ {
+ // Check connection:
+ if (!ConnectionManager::ConnectionIsValid(dbsettings))
+ {
+ ARMARX_WARNING << deactivateSpam("LTM_ConnectionError_" + cache.name())
+ << "The connection to mongocxx for ltm '" << cache.name() << "' is not valid. Settings are: " << dbsettings.toString()
+ << "\nTo start it, run e.g.: \n"
+ << "armarx memory start"
+ << "\n\n";
+ return nullptr;
+ }
+
+ auto& pool = ConnectionManager::Connect(dbsettings);
+ auto client = pool.acquire();
+
+ return client;
+ }
+
+ void Memory::reload()
+ {
+ TIMING_START(LTM_Reload);
+ ARMARX_DEBUG << "(Re)Establishing connection to: " << dbsettings.toString();
+
+ auto client = checkConnection();
+ if (!client)
+ {
+ return;
+ }
+
+ std::lock_guard l(ltm_mutex);
+ auto databases = client->list_databases();
+ std::stringstream ss;
+ ss << "Found Memory-Collection in MongoDB for '" + cache.name() + "': \n";
+ for (const auto& doc : databases)
+ {
+ auto el = doc["name"];
+ ss << "\t - " << el.get_utf8().value << "\n";
+ }
+ ARMARX_DEBUG << ss.str();
+
+ armem::wm::Memory temp(lut.id());
+ mongocxx::database db = client->database(dbsettings.database);
+ util::load(db, temp);
+
+ lut.append(temp);
+
+ TIMING_END_STREAM(LTM_Reload, ARMARX_DEBUG);
+ }
+
+ void Memory::convert(armem::wm::Memory& m)
+ {
+ TIMING_START(LTM_Convert);
+
+ auto client = checkConnection();
+ if (!client)
+ {
+ return;
+ }
+
+ std::lock_guard l(ltm_mutex);
+ mongocxx::database db = client->database(dbsettings.database);
+
+ util::convert(db, m);
+
+ TIMING_END_STREAM(LTM_Convert, ARMARX_DEBUG);
+ }
+
+ void Memory::encodeAndStore()
+ {
+ TIMING_START(LTM_Encode);
+
+ auto client = checkConnection();
+ if (!client)
+ {
+ return;
+ }
+
+ std::lock_guard l(ltm_mutex);
+ mongocxx::database db = client->database(dbsettings.database);
+ util::store(db, cache);
+
+ // what to do with clear text data after encoding?
+ // TODO!
+
+ // Finaly clear cache and put reference to lut
+ moveCacheToLUTAndClearCache();
+
+ TIMING_END_STREAM(LTM_Encode, ARMARX_DEBUG);
+ }
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.h b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..6809bb596692fae617e45ee4eb16368ccd905366
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/MemoryManager.h
@@ -0,0 +1,40 @@
+#pragma once
+
+// STD / STL
+#include <mutex>
+#include <optional>
+
+// Base Class
+#include "../MemoryBase.h"
+
+// Data
+# include "ConnectionManager.h"
+
+namespace armarx::armem::server::ltm::mongodb
+{
+ /// @brief A memory storing data in mongodb (needs 'armarx memory start' to start the mongod instance)
+ class Memory :
+ public MemoryBase
+ {
+ using Base = MemoryBase;
+
+ public:
+ using Base::MemoryBase;
+ using Base::convert;
+
+ Memory() = default;
+
+ void reload() override;
+ void convert(armem::wm::Memory&) override;
+ void encodeAndStore() override;
+
+ private:
+ PoolClientPtr checkConnection() const; // return nullptr if not possible
+
+ public:
+ ConnectionManager::MongoDBSettings dbsettings;
+
+ private:
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.cpp b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f4169a858fadd55757b04055b80d8836dad4a131
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.cpp
@@ -0,0 +1,314 @@
+#include "operations.h"
+
+// Simox
+#include <SimoxUtility/json.h>
+
+#include "../operations.h"
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
+
+namespace armarx::armem::server::ltm::mongodb::util
+{
+ namespace bsoncxxbuilder = bsoncxx::builder::stream;
+ namespace bsoncxxdoc = bsoncxx::document;
+
+ namespace
+ {
+ void mongodbInsertForeignKey(mongocxx::collection& coll, const std::string& key)
+ {
+ auto q = bsoncxxbuilder::document{} << std::string(constantes::FOREIGN_KEY) << key << bsoncxxbuilder::finalize;
+ coll.insert_one(q.view());
+ }
+
+ bool mongodbContainsForeignKey(mongocxx::collection& coll, const std::string& key)
+ {
+ // check mongodb
+ auto q = bsoncxxbuilder::document{} << std::string(constantes::FOREIGN_KEY) << key << bsoncxxbuilder::finalize;
+ auto res = coll.find_one(q.view());
+ return (bool) res;
+ }
+
+ bool mongodbContainsTimestamp(mongocxx::collection& coll, const long ts)
+ {
+ // check mongodb
+ auto q = bsoncxxbuilder::document{} << std::string(constantes::TIMESTAMP) << ts << bsoncxxbuilder::finalize;
+ auto res = coll.find_one(q.view());
+ return (bool) res;
+ }
+ }
+
+ void load(const mongocxx::database& db, armem::wm::Memory& m)
+ {
+ if (!db.has_collection(m.id().str()))
+ {
+ return;
+ }
+ mongocxx::collection coll = db.collection(m.id().str());
+ mongocxx::cursor cursor = coll.find({});
+ for (const auto& doc : cursor)
+ {
+ auto el = doc[constantes::FOREIGN_KEY];
+ auto foreignKey = el.get_utf8().value;
+
+ MemoryID i((std::string) foreignKey);
+ if (i.memoryName != m.id().memoryName)
+ {
+ throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
+ }
+
+ std::string k = i.coreSegmentName;
+ if (m.hasCoreSegment(k))
+ {
+ throw error::ArMemError("Somehow the container already contains the key k = " + k + ". Do you have double entries in mongodb?");
+ }
+ else
+ {
+ auto& cSeg = m.addCoreSegment(k);
+ load(db, cSeg);
+ }
+ }
+ }
+
+ void load(const mongocxx::database& db, armem::wm::CoreSegment& c)
+ {
+ if (!db.has_collection(c.id().str()))
+ {
+ return;
+ }
+ mongocxx::collection coll = db.collection(c.id().str());
+ mongocxx::cursor cursor = coll.find({});
+ for (const auto& doc : cursor)
+ {
+ auto el = doc[constantes::FOREIGN_KEY];
+ auto foreignKey = el.get_utf8().value;
+
+ MemoryID i((std::string) foreignKey);
+ if (i.coreSegmentName != c.id().coreSegmentName ||
+ i.memoryName != c.id().memoryName)
+ {
+ throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
+ }
+
+ std::string k = i.providerSegmentName;
+ if (c.hasProviderSegment(k))
+ {
+ throw error::ArMemError("Somehow the container already contains the key k = " + k + ". Do you have double entries in mongodb?");
+ }
+ else
+ {
+ auto& pSeg = c.addProviderSegment(k);
+ load(db, pSeg);
+ }
+ }
+ }
+
+ void load(const mongocxx::database& db, armem::wm::ProviderSegment& p)
+ {
+ if (!db.has_collection(p.id().str()))
+ {
+ return;
+ }
+ mongocxx::collection coll = db.collection(p.id().str());
+ mongocxx::cursor cursor = coll.find({});
+ for (const auto& doc : cursor)
+ {
+ auto el = doc[constantes::FOREIGN_KEY];
+ auto foreignKey = el.get_utf8().value;
+
+ MemoryID i((std::string) foreignKey);
+ if (i.providerSegmentName != p.id().providerSegmentName ||
+ i.coreSegmentName != p.id().coreSegmentName ||
+ i.memoryName != p.id().memoryName)
+ {
+ throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
+ }
+
+ std::string k = i.entityName;
+ if (p.hasEntity(k))
+ {
+ throw error::ArMemError("Somehow the container already contains the key k = " + k + ". Do you have double entries in mongodb?");
+ }
+ else
+ {
+ auto& eSeg = p.addEntity(k);
+ load(db, eSeg);
+ }
+ }
+ }
+
+ void load(const mongocxx::database& db, armem::wm::Entity& e)
+ {
+ if (!db.has_collection(e.id().str()))
+ {
+ return;
+ }
+ mongocxx::collection coll = db.collection(e.id().str());
+ mongocxx::cursor cursor = coll.find({});
+ for (const auto& doc : cursor)
+ {
+ auto ts = armem::Time::microSeconds(doc[constantes::TIMESTAMP].get_int64().value);
+ auto& newSnapshot = e.addSnapshot(ts);
+
+ auto i = doc[constantes::INSTANCES];
+ unsigned long length = std::distance(i.get_array().value.begin(), i.get_array().value.end());
+
+ for (unsigned long i = 0; i < length; ++i)
+ {
+ // add an empty instance as reference
+ newSnapshot.addInstance({});
+ }
+
+ // check to update lastSnapshot map TODO
+ //checkUpdateLatestSnapshot(newSnapshot);
+ }
+ }
+
+ void convert(const mongocxx::database& db, armem::wm::Memory& m)
+ {
+ m.forEachCoreSegment([&db](armem::wm::CoreSegment & e)
+ {
+ convert(db, e);
+ });
+ }
+
+ void convert(const mongocxx::database& db, armem::wm::CoreSegment& c)
+ {
+ c.forEachProviderSegment([&db](armem::wm::ProviderSegment & e)
+ {
+ convert(db, e);
+ });
+ }
+
+ void convert(const mongocxx::database& db, armem::wm::ProviderSegment& p)
+ {
+ p.forEachEntity([&db](armem::wm::Entity & e)
+ {
+ convert(db, e);
+ });
+ }
+
+ void convert(const mongocxx::database& db, armem::wm::Entity& e)
+ {
+ e.forEachSnapshot([&db](armem::wm::EntitySnapshot & e)
+ {
+ if (!ltm::util::entityHasData(e))
+ {
+ // Get data from mongodb
+ auto eColl = db.collection(e.id().getEntityID().str());
+ auto q = bsoncxxbuilder::document{} << std::string(constantes::TIMESTAMP) << e.id().timestamp.toMicroSeconds() << bsoncxxbuilder::finalize;
+ auto res = eColl.find_one(q.view());
+
+ if (!res)
+ {
+ // break if the data could not be found in ltm storage
+ // perhaps its a not-set maybe type from the cache (not yet consollidated to ltm)
+ return false;
+ }
+
+ // convert full json of this entry
+ nlohmann::json json = nlohmann::json::parse(bsoncxx::to_json(*res));
+ nlohmann::json instances = json[constantes::INSTANCES];
+
+ if (instances.size() != e.size())
+ {
+ throw error::ArMemError("The size of the mongodb entity entry at id " + e.id().getEntitySnapshotID().str() + " has wrong size. Expected: " + std::to_string(e.size()) + " but got: " + std::to_string(instances.size()));
+ }
+
+ for (unsigned int i = 0; i < e.size(); ++i)
+ {
+ auto& ins = e.getInstance(e.id().withInstanceIndex(i));
+
+ // get ionstance json
+ nlohmann::json doc = instances[i];
+ auto aron = aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(doc);
+
+ // remove metadata
+ wm::EntityInstance tmp(e.id().withInstanceIndex(i));
+ from_aron(aron, tmp);
+
+ // set data
+ ins.data() = tmp.data();
+ }
+ }
+ return true;
+ });
+ }
+
+ void store(const mongocxx::database& db, const armem::wm::Memory& m)
+ {
+ auto coll = db.collection(m.id().str());
+ m.forEachCoreSegment([&db, &coll](armem::wm::CoreSegment & e)
+ {
+ if (!mongodbContainsForeignKey(coll, e.id().str()))
+ {
+ mongodbInsertForeignKey(coll, e.id().str());
+ }
+
+ store(db, e);
+ });
+ }
+
+ void store(const mongocxx::database& db, const armem::wm::CoreSegment& c)
+ {
+ auto coll = db.collection(c.id().str());
+ c.forEachProviderSegment([&db, &coll](armem::wm::ProviderSegment & e)
+ {
+ if (!mongodbContainsForeignKey(coll, e.id().str()))
+ {
+ mongodbInsertForeignKey(coll, e.id().str());
+ }
+
+ store(db, e);
+ });
+ }
+
+ void store(const mongocxx::database& db, const armem::wm::ProviderSegment& p)
+ {
+ auto coll = db.collection(p.id().str());
+ p.forEachEntity([&db, &coll](armem::wm::Entity & e)
+ {
+ if (!mongodbContainsForeignKey(coll, e.id().str()))
+ {
+ mongodbInsertForeignKey(coll, e.id().str());
+ }
+
+ store(db, e);
+ });
+ }
+
+ void store(const mongocxx::database& db, const armem::wm::Entity& e)
+ {
+ auto coll = db.collection(e.id().str());
+ e.forEachSnapshot([&coll](armem::wm::EntitySnapshot & e)
+ {
+ if (!mongodbContainsTimestamp(coll, e.id().timestamp.toMilliSeconds()))
+ {
+ // timestamp not found in mongodb ==> new entry
+ bsoncxxbuilder::document builder{};
+ auto in_array = builder
+ << std::string(constantes::ID) << e.id().str()
+ << std::string(constantes::TIMESTAMP) << e.id().timestamp.toMicroSeconds()
+ << std::string(constantes::INSTANCES);
+ auto array_builder = bsoncxx::builder::basic::array{};
+
+ e.forEachInstance([&array_builder](const wm::EntityInstance & e)
+ {
+ auto aron = std::make_shared<aron::data::Dict>();
+ to_aron(aron, e);
+ nlohmann::json j = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(aron);
+
+ auto doc_value = bsoncxx::from_json(j.dump(2));
+ array_builder.append(doc_value);
+ });
+
+ auto after_array = in_array << array_builder;
+ bsoncxx::document::value doc = after_array << bsoncxx::builder::stream::finalize;
+ coll.insert_one(doc.view());
+
+ // check to update lastSnapshot map TODO
+ //checkUpdateLatestSnapshot(e);
+ }
+ });
+ }
+
+} // namespace armarx::armem::server::ltm
diff --git a/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.h b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.h
new file mode 100644
index 0000000000000000000000000000000000000000..c81c2312e3e4083e1323465cb5b92ee54bb75818
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/ltm/legacy/mongodb/operations.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <RobotAPI/libraries/armem/core/forward_declarations.h>
+#include <RobotAPI/libraries/armem/server/forward_declarations.h>
+
+// Data
+# include "ConnectionManager.h"
+
+namespace armarx::armem::server::ltm::mongodb
+{
+
+ namespace constantes
+ {
+ const std::string FOREIGN_KEY = "foreign_key";
+ const std::string ID = "id";
+ const std::string TIMESTAMP = "timestamp";
+ const std::string INSTANCES = "instances";
+ }
+
+ namespace util
+ {
+ void load(const mongocxx::database& db, armem::wm::Memory& memory);
+ void load(const mongocxx::database& db, armem::wm::CoreSegment& memory);
+ void load(const mongocxx::database& db, armem::wm::ProviderSegment& memory);
+ void load(const mongocxx::database& db, armem::wm::Entity& memory);
+
+ void convert(const mongocxx::database& db, armem::wm::Memory& memory);
+ void convert(const mongocxx::database& db, armem::wm::CoreSegment& memory);
+ void convert(const mongocxx::database& db, armem::wm::ProviderSegment& memory);
+ void convert(const mongocxx::database& db, armem::wm::Entity& memory);
+
+ void store(const mongocxx::database& db, const armem::wm::Memory& memory);
+ void store(const mongocxx::database& db, const armem::wm::CoreSegment& memory);
+ void store(const mongocxx::database& db, const armem::wm::ProviderSegment& memory);
+ void store(const mongocxx::database& db, const armem::wm::Entity& memory);
+ }
+
+} // namespace armarx::armem::server::ltm::mongodb
diff --git a/source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.cpp b/source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.cpp
deleted file mode 100644
index ad2d95b0fed35991ae99e050a9939537a840a2a2..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/mongodb/ConnectionManager.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "ConnectionManager.h"
-
-namespace armarx::armem::server::ltm::mongodb
-{
- std::mutex ConnectionManager::initializationMutex;
- bool ConnectionManager::initialized = false;
- std::map<std::string, std::unique_ptr<mongocxx::pool>> ConnectionManager::Connections = {};
-
-
- void ConnectionManager::initialize_if()
- {
- std::lock_guard l(initializationMutex); // all others have to wait until the initialization is complete
- if (!initialized)
- {
- initialized = true;
- mongocxx::instance instance{}; // This should be done only once.
- }
- }
-
- mongocxx::pool& ConnectionManager::Connect(const MongoDBSettings& settings)
- {
- initialize_if();
-
- const auto uri_str = settings.uri();
- auto it = Connections.find(uri_str);
- if (it == Connections.end())
- {
- mongocxx::uri uri(uri_str);
- auto pool = std::make_unique<mongocxx::pool>(uri);
- auto con = Connections.emplace(settings.key(), std::move(pool));
- return *con.first->second;
- }
- else
- {
- // A connection already exists. We do not need to open another one.
- return *it->second;
- }
- }
-
- bool ConnectionManager::ConnectionIsValid(const MongoDBSettings& settings, bool forceNewConnection)
- {
- initialize_if();
-
- try
- {
- if (!forceNewConnection)
- {
- auto it = Connections.find(settings.key());
- if (it != Connections.end())
- {
- auto client = it->second->acquire();
- auto admin = client->database("admin");
- auto result = admin.run_command(bsoncxx::builder::basic::make_document(bsoncxx::builder::basic::kvp("isMaster", 1)));
- return true;
- }
- }
-
- mongocxx::uri uri(settings.uri());
- auto client = mongocxx::client(uri);
- auto admin = client["admin"];
- auto result = admin.run_command(bsoncxx::builder::basic::make_document(bsoncxx::builder::basic::kvp("isMaster", 1)));
- return true;
- }
- catch (const std::exception& xcp)
- {
- return false;
- }
- }
-
- bool ConnectionManager::ConnectionExists(const MongoDBSettings& settings)
- {
- initialize_if();
-
- auto it = Connections.find(settings.key());
- return it != Connections.end();
- }
-}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.cpp b/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.cpp
deleted file mode 100644
index 73a06f5bda18fbc90f3d95be12987fc382eb2b82..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.cpp
+++ /dev/null
@@ -1,426 +0,0 @@
-// Header
-#include "MemoryManager.h"
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// ArmarX
-#include <ArmarXCore/core/time/TimeUtil.h>
-#include <ArmarXCore/core/logging/Logging.h>
-
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
-#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
-
-
-namespace armarx::armem::server::ltm::mongodb
-{
- namespace bsoncxxbuilder = bsoncxx::builder::stream;
- namespace bsoncxxdoc = bsoncxx::document;
-
- PoolClientPtr MemoryManager::checkConnection() const
- {
- // Check connection:
- ARMARX_INFO << "Checking connection";
- if (!ConnectionManager::ConnectionIsValid(dbsettings))
- {
- ARMARX_WARNING << deactivateSpam("ConnectionIsNotValid")
- << "The connection to mongocxx for ltm '" << cache.name() << "' is not valid. Settings are: " << dbsettings.toString()
- << "\nTo start it, run e.g.: \n"
- << "armarx memory start"
- << "\n\n";
- return nullptr;
- }
-
- auto& pool = ConnectionManager::Connect(dbsettings);
- auto client = pool.acquire();
-
- return client;
- }
-
- void MemoryManager::reload()
- {
- TIMING_START(LTM_Reload);
- ARMARX_INFO << "(Re)Establishing connection to: " << dbsettings.toString();
-
- auto client = checkConnection();
- if (!client)
- {
- // abort
- ARMARX_WARNING << "A connection to: " << dbsettings.toString() << " is not possible. Could not (pre)load data from mongodb.";
- return;
- }
-
- auto databases = client->list_databases();
- for (const auto& doc : databases)
- {
- auto el = doc["name"];
- ARMARX_INFO << "Found Memory-Collection in MongoDB: " << el.get_utf8().value;
- }
-
- armem::wm::Memory temp(lut.id()); // a temporary client wm. We will append temp to the lut at the end of this metho (append ignores duplicate entries)
- mongocxx::database db = client->database(dbsettings.database);
-
- ARMARX_INFO << "Loading memory: " << temp.id().str();
-
- // ///////////////////////////////
- // Iterate over core segments
- // ///////////////////////////////
- mongocxx::collection mColl = db.collection(temp.id().str());
- mongocxx::cursor cursor = mColl.find({});
- for (const auto& doc : cursor) // Although this looks like code duplication, we need a distinguition between memories,
- // core, prov and entities because of a different structure
- // (only core and prov have same structure)
- {
- auto el = doc[MONGO_FOREIGN_KEY];
- auto foreignKey = el.get_utf8().value;
-
- MemoryID i((std::string) foreignKey);
- if (i.memoryName != temp.id().memoryName)
- {
- throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
- }
-
- std::string k = i.coreSegmentName;
-
- if (temp.hasCoreSegment(k))
- {
- throw error::ArMemError("Somehow the (memory) container already contains the key k = " + k + ". Do you have double entries in mongodb?");
- }
- else
- {
- // ///////////////////////////////
- // Add and iterate over provider segments
- // ///////////////////////////////
- auto& cSeg = temp.addCoreSegment(k);
- mongocxx::collection cColl = db.collection(cSeg.id().str());
- mongocxx::cursor cursor = cColl.find({});
- for (const auto& doc : cursor)
- {
- auto el = doc[MONGO_FOREIGN_KEY];
- auto foreignKey = el.get_utf8().value;
-
- MemoryID i((std::string) foreignKey);
- if (i.coreSegmentName != cSeg.id().coreSegmentName || i.memoryName != cSeg.id().memoryName)
- {
- throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
- }
-
- std::string k = i.providerSegmentName;
- if (cSeg.hasProviderSegment(k))
- {
- throw error::ArMemError("Somehow the (core segment) container already contains the key k = " + k + ". Do you have double entries in mongodb?");
- }
- else
- {
- // ///////////////////////////////
- // Add and iterate over entities
- // ///////////////////////////////
- auto& pSeg = cSeg.addProviderSegment(k);
- mongocxx::collection pColl = db.collection(pSeg.id().str());
- mongocxx::cursor cursor = pColl.find({});
- for (const auto& doc : cursor)
- {
- auto el = doc[MONGO_FOREIGN_KEY];
- auto foreignKey = el.get_utf8().value;
-
- MemoryID i((std::string) foreignKey);
- if (i.providerSegmentName != pSeg.id().providerSegmentName || i.coreSegmentName != pSeg.id().coreSegmentName || i.memoryName != pSeg.id().memoryName)
- {
- throw error::InvalidMemoryID(i, "A MemoryID in mongodb was invalid. Found the wrong memory name: " + i.str());
- }
-
- std::string k = i.entityName;
- if (pSeg.hasEntity(k))
- {
- throw error::ArMemError("Somehow the (provider segment) container already contains the key k = " + k + ". Do you have double entries in mongodb?");
- }
- else
- {
- // ///////////////////////////////
- // Add and iterate over snapshots
- // ///////////////////////////////
- auto& eSeg = pSeg.addEntity(k);
- mongocxx::collection eColl = db.collection(eSeg.id().str());
- mongocxx::cursor cursor = eColl.find({});
- for (const auto& doc : cursor)
- {
- auto ts = armem::Time::microSeconds(doc[MONGO_TIMESTAMP].get_int64().value);
- auto& newSnapshot = eSeg.addSnapshot(ts);
-
- auto i = doc[MONGO_INSTANCES];
- unsigned long length = std::distance(i.get_array().value.begin(), i.get_array().value.end());
- ARMARX_INFO << "The array legth for an snapshot '" << newSnapshot.id().str() << "' is: " << length;
-
- for (unsigned long i = 0; i < length; ++i)
- {
- // add an empty instance as reference
- newSnapshot.addInstance({});
- }
-
-
- // check to update lastSnapshot map
- checkUpdateLatestSnapshot(newSnapshot);
- }
- }
- }
- }
- }
- }
- }
-
- std::lock_guard l(cache_mutex); // we always take the cache mutex BEFORE the lut mutex! (otherwise we may have deadlocks)
- std::lock_guard l2(lut_mutex);
- lut.append(temp);
- ARMARX_INFO << "After reload memory " << lut.id().str() << " has size: " << lut.size();
-
- TIMING_END(LTM_Reload);
- }
-
- void MemoryManager::convert(armem::wm::Memory& m)
- {
- TIMING_START(LTM_Convert);
-
- auto client = checkConnection();
- if (!client)
- {
- // abort
- ARMARX_WARNING << "A connection to: " << dbsettings.toString() << " is not possible. Could not convert information, therefore returning leaving input untouched.";
- return;
- }
- mongocxx::database db = client->database(dbsettings.database);
-
- // update emtpy data ptr
- m.forEachCoreSegment([&db](armem::wm::CoreSegment & e)
- {
- e.forEachProviderSegment([&db](armem::wm::ProviderSegment & e)
- {
- e.forEachEntity([&db](armem::wm::Entity & e)
- {
- e.forEachSnapshot([&db](armem::wm::EntitySnapshot & e)
- {
- // check whether data is nullptr
- bool allDataIsNull = e.size() > 0;
- e.forEachInstance([&allDataIsNull](armem::wm::EntityInstance & e)
- {
- if (e.data())
- {
- allDataIsNull = false;
- return false; // means break
- }
- return true;
- });
-
- if (allDataIsNull) // an entry from the lut (probably... for now we assume that every entry either has data (cache) or has null (lut))
- {
- // Get data from mongodb
- auto eColl = db.collection(e.id().getEntityID().str());
- auto q = bsoncxxbuilder::document{} << std::string(MONGO_TIMESTAMP) << e.id().timestamp.toMicroSeconds() << bsoncxxbuilder::finalize;
- auto res = eColl.find_one(q.view());
-
- if (!res)
- {
- throw error::ArMemError("Could not load an instance from the memory '" + e.id().getEntityID().str() + "'. Tried to access: " + e.id().getEntitySnapshotID().str());
- }
-
- // convert full json of this entry
- nlohmann::json json = nlohmann::json::parse(bsoncxx::to_json(*res));
- nlohmann::json instances = json[MONGO_INSTANCES];
-
- if (instances.size() != e.size())
- {
- throw error::ArMemError("The size of the mongodb entity entry at id " + e.id().getEntitySnapshotID().str() + " has wrong size. Expected: " + std::to_string(e.size()) + " but got: " + std::to_string(instances.size()));
- }
-
- for (unsigned int i = 0; i < e.size(); ++i)
- {
- auto& ins = e.getInstance(i);
-
- // get ionstance json
- nlohmann::json doc = instances[i];
- auto aron = aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSON(doc);
-
- // remove metadata
- wm::EntityInstance tmp(e.id().withInstanceIndex(i));
- from_aron(aron, tmp);
-
- // set data
- ins.data() = tmp.data();
- }
- }
- });
- });
- });
- });
- TIMING_END(LTM_Convert);
- }
-
- void MemoryManager::encodeAndStore()
- {
- TIMING_START(LTM_Encode);
- ARMARX_INFO << "Encode cache " << cache.id().str() << " with size: " << cache.size();
-
- auto client = checkConnection();
- if (!client)
- {
- // abort
- ARMARX_WARNING << "A connection to: " << dbsettings.toString() << " is not possible. Could not consolidate data from cache to mongodb.";
- return;
- }
-
- std::lock_guard l(cache_mutex);
- mongocxx::database db = client->database(dbsettings.database);
- auto mColl = db.collection(cache.id().str());
-
- // ///////////////////////////////
- // Iterate over core segments
- // ///////////////////////////////
- cache.forEachCoreSegment([this, &db, &mColl](armem::wm::CoreSegment & e)
- {
- auto cColl = db.collection(e.id().str());
-
- if (!containsCoreSegment(mColl, e.id()))
- {
- // not found
- mongodbInsertForeignKey(mColl, e.id().str());
- }
-
- // ///////////////////////////////
- // Iterate over provider segments
- // ///////////////////////////////
- e.forEachProviderSegment([this, &db, &cColl](armem::wm::ProviderSegment & e)
- {
- auto pColl = db.collection(e.id().str());
-
- if (!containsProviderSegment(cColl, e.id()))
- {
- // not found
- mongodbInsertForeignKey(cColl, e.id().str());
- }
-
- // ///////////////////////////////
- // Iterate over each segments
- // ///////////////////////////////
- e.forEachEntity([this, &db, &pColl](armem::wm::Entity & e)
- {
- auto eColl = db.collection(e.id().str());
-
- if (!containsEntity(pColl, e.id()))
- {
- // not found
- mongodbInsertForeignKey(pColl, e.id().str());
- }
-
- // ///////////////////////////////
- // Iterate over snapshots
- // ///////////////////////////////
- e.forEachSnapshot([this, &eColl](armem::wm::EntitySnapshot & e)
- {
- if (!this->containsSnapshot(eColl, e.id()))
- {
- // timestamp not found in mongodb ==> new entry
- bsoncxxbuilder::document builder{};
- auto in_array = builder
- << std::string(MONGO_ID) << e.id().str()
- << std::string(MONGO_TIMESTAMP) << e.id().timestamp.toMicroSeconds()
- << std::string(MONGO_INSTANCES);
- auto array_builder = bsoncxx::builder::basic::array{};
-
- e.forEachInstance([&array_builder](const wm::EntityInstance & e)
- {
- auto aron = std::make_shared<aron::datanavigator::DictNavigator>();
- to_aron(aron, e);
- nlohmann::json j = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(aron);
-
- auto doc_value = bsoncxx::from_json(j.dump(2));
- array_builder.append(doc_value);
- });
-
- auto after_array = in_array << array_builder;
- bsoncxx::document::value doc = after_array << bsoncxx::builder::stream::finalize;
- ARMARX_INFO << "Insert into mongodb: " << e.id().timestamp.toMicroSeconds();
- eColl.insert_one(doc.view());
-
- // check to update lastSnapshot map
- checkUpdateLatestSnapshot(e);
- }
- else
- {
- ARMARX_INFO << "Timestamp already found for id: " << e.id().str();
- // timestamp already in mongodb. Ignore it
- }
- });
- });
- });
- });
-
- // what to do with clear text data after encoding?
- // TODO!
-
- // Finaly clear cache and put reference to lut
- cache.forEachInstance([](armem::wm::EntityInstance & i)
- {
- i.data() = nullptr;
- });
-
- std::lock_guard l2(lut_mutex);
- lut.append(cache);
- cache.clear();
-
- TIMING_END(LTM_Encode);
- }
-
- void MemoryManager::mongodbInsertForeignKey(mongocxx::collection& coll, const std::string& key)
- {
- auto q = bsoncxxbuilder::document{} << std::string(MONGO_FOREIGN_KEY) << key << bsoncxxbuilder::finalize;
- coll.insert_one(q.view());
- }
-
- bool MemoryManager::mongodbContainsForeignKey(mongocxx::collection& coll, const std::string& key) const
- {
- // check mongodb
- auto q = bsoncxxbuilder::document{} << std::string(MONGO_FOREIGN_KEY) << key << bsoncxxbuilder::finalize;
- auto res = coll.find_one(q.view());
- return (bool) res;
- }
-
- bool MemoryManager::containsCoreSegment(mongocxx::collection& mColl, const MemoryID& coreSegmentID) const
- {
- if (Base::containsCoreSegment(coreSegmentID))
- {
- return true;
- }
- return mongodbContainsForeignKey(mColl, coreSegmentID.str());
- }
-
- bool MemoryManager::containsProviderSegment(mongocxx::collection& cColl, const MemoryID& providerSegmentID) const
- {
- if (Base::containsProviderSegment(providerSegmentID))
- {
- return true;
- }
- return mongodbContainsForeignKey(cColl, providerSegmentID.str());
- }
-
- bool MemoryManager::containsEntity(mongocxx::collection& pColl, const MemoryID& entityID) const
- {
- if (Base::containsEntity(entityID))
- {
- return true;
- }
- return mongodbContainsForeignKey(pColl, entityID.str());
- }
-
- bool MemoryManager::containsSnapshot(mongocxx::collection& eColl, const MemoryID& snapshotID) const
- {
- if (Base::containsSnapshot(snapshotID))
- {
- return true;
- }
-
- // check mongodb
- auto q = bsoncxxbuilder::document{} << std::string(MONGO_TIMESTAMP) << snapshotID.timestamp.toMicroSeconds() << bsoncxxbuilder::finalize;
- auto res = eColl.find_one(q.view());
- return (bool) res;
- }
-}
diff --git a/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.h b/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.h
deleted file mode 100644
index 189ccc42563d17dd63116dc3210d99d648b28c31..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-// STD / STL
-#include <mutex>
-#include <optional>
-
-// Base Class
-#include "../LongtermMemoryBase.h"
-
-// Data
-# include "ConnectionManager.h"
-
-namespace armarx::armem::server::ltm::mongodb
-{
- /// @brief A memory storing data in mongodb (needs 'armarx memory start' to start the mongod instance)
- class MemoryManager :
- public LongtermMemoryBase
- {
- using Base = LongtermMemoryBase;
-
- public:
- MemoryManager() = default;
-
- void reload() override;
- void convert(armem::wm::Memory&) override;
- void encodeAndStore() override;
-
- protected:
-
-
- private:
- PoolClientPtr checkConnection() const; // return nullptr if not possible
-
- void mongodbInsertForeignKey(mongocxx::collection&, const std::string& key);
-
- bool mongodbContainsForeignKey(mongocxx::collection&, const std::string& key) const;
- bool containsCoreSegment(mongocxx::collection&, const MemoryID&) const;
- bool containsProviderSegment(mongocxx::collection&, const MemoryID&) const;
- bool containsEntity(mongocxx::collection&, const MemoryID&) const;
- bool containsSnapshot(mongocxx::collection&, const MemoryID&) const;
-
- public:
- ConnectionManager::MongoDBSettings dbsettings;
-
- private:
- static const constexpr char* MONGO_FOREIGN_KEY = "foreign_key";
- static const constexpr char* MONGO_ID = "id";
- static const constexpr char* MONGO_TIMESTAMP = "timestamp";
- static const constexpr char* MONGO_INSTANCES = "instances";
- };
-}
diff --git a/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp b/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
index 031e8fbdfe55b1024bac050b341327e6ef16e482..327a83223a88ad34adad181d922ea1d4e63ebdf8 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
+++ b/source/RobotAPI/libraries/armem/server/plugins/Plugin.cpp
@@ -30,8 +30,16 @@ namespace armarx::armem::server::plugins
{
properties->optional(workingMemory.name(), prefix + "MemoryName", "Name of this memory server.");
}
- properties->optional(longtermMemoryEnabled, prefix + "ltm.00_enabled");
+ // stuff for ltm
+ if (longtermMemory.enabled) // if not explicitly set to false in constructor of component (then we dont need the params)
+ {
+ if (not properties->hasDefinition(prefix + "ltm.enabled"))
+ {
+ properties->optional(longtermMemory.enabled, prefix + "ltm.enabled");
+ }
+ //longtermMemory.createPropertyDefinitions(properties, "ltm.");
+ }
// Publish memory updates topic
properties->topic(memoryTopic, memoryTopicDefaultName);
@@ -47,12 +55,6 @@ namespace armarx::armem::server::plugins
registerServer(parent);
}
iceAdapter.setMemoryListener(memoryTopic);
-
- // establishing connection to ltm and mongodb
- if (longtermMemoryEnabled)
- {
- longtermMemoryManager.reload();
- }
}
@@ -68,7 +70,7 @@ namespace armarx::armem::server::plugins
void Plugin::setMemoryName(const std::string& memoryName)
{
workingMemory.name() = memoryName;
- longtermMemoryManager.setName(memoryName);
+ longtermMemory.setMemoryID(workingMemory.id());
}
diff --git a/source/RobotAPI/libraries/armem/server/plugins/Plugin.h b/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
index 49cc07bb08dc7265fa797e2f5f77a3d81511c33c..8a5a68934003997a9588117ecc985f2fa9dfe456 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
+++ b/source/RobotAPI/libraries/armem/server/plugins/Plugin.h
@@ -3,7 +3,6 @@
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-#include <RobotAPI/libraries/armem/server/ltm/mongodb/MemoryManager.h>
#include <RobotAPI/interface/armem/client/MemoryListenerInterface.h>
#include <RobotAPI/interface/armem/mns/MemoryNameSystemInterface.h>
@@ -70,7 +69,7 @@ namespace armarx::armem::server::plugins
server::wm::Memory workingMemory;
/// Helps connecting `memory` to ice. Used to handle Ice callbacks.
- MemoryToIceAdapter iceAdapter { &workingMemory, &longtermMemoryManager};
+ MemoryToIceAdapter iceAdapter { &workingMemory, &longtermMemory};
// Working Memory Updates (publishing)
@@ -81,20 +80,13 @@ namespace armarx::armem::server::plugins
// Long-Term Memory
- /// Indicates whether to use or not to use the ltm feature.
- bool longtermMemoryEnabled = true;
-
/// A manager class for the ltm. It internally holds a normal wm instance as a cache.
- server::ltm::mongodb::MemoryManager longtermMemoryManager;
-
- std::string longTermMemoryDatabaseHost;
- std::string longTermMemoryDatabaseUser;
- std::string longTermMemoryDatabasePassword;
+ server::ltm::disk::Memory longtermMemory;
private:
- client::plugins::Plugin* clientPlugin;
+ client::plugins::Plugin* clientPlugin = nullptr;
};
}
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
index f3da4f3ee885a2f1cda0a86ad195ae466f4fb9e5..285c65e0b02895bbb59663a461db1249330daf13 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
@@ -86,15 +86,9 @@ namespace armarx::armem::server::plugins
}
- bool ReadWritePluginUser::isLongtermMemoryEnabled()
+ ltm::disk::Memory& ReadWritePluginUser::longtermMemory()
{
- return plugin->longtermMemoryEnabled;
- }
-
-
- ltm::mongodb::MemoryManager& ReadWritePluginUser::longtermMemoryManager()
- {
- return plugin->longtermMemoryManager;
+ return plugin->longtermMemory;
}
}
diff --git a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
index 6736224199489fb171d49b092fd91e88e59fd9b0..8d3dad4c98d3f11592b250ce11a10fc96dc8cd81 100644
--- a/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
+++ b/source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
@@ -55,8 +55,7 @@ namespace armarx::armem::server::plugins
server::wm::Memory& workingMemory();
MemoryToIceAdapter& iceAdapter();
- bool isLongtermMemoryEnabled();
- server::ltm::mongodb::MemoryManager& longtermMemoryManager();
+ server::ltm::disk::Memory& longtermMemory();
private:
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
index 73c662e04ebd734cbe79c3b19f676f684223a88c..b4ad4300d01835654882b65be10271ecfe27a754 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/BaseQueryProcessorBase.h
@@ -36,7 +36,6 @@ namespace armarx::armem::server::query_proc::base
virtual ~BaseQueryProcessorBase() = default;
-
ResultT process(const QueryT& query, const DataT& data) const
{
ResultT result { data.id() };
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
index 0c6199eac95465a27da8bc0d59b4fcd40607d139..dc84c257a0f08307cb30971390d717534c6db2f4 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/CoreSegmentQueryProcessorBase.h
@@ -18,6 +18,8 @@ namespace armarx::armem::server::query_proc::base
class CoreSegmentQueryProcessorBase :
public BaseQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>
{
+ protected:
+
using Base = BaseQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, armem::query::data::CoreSegmentQuery>;
public:
@@ -65,7 +67,7 @@ namespace armarx::armem::server::query_proc::base
}
}
- void process(ResultCoreSegmentT& result,
+ virtual void process(ResultCoreSegmentT& result,
const armem::query::data::core::All& query,
const CoreSegmentT& coreSegment) const
{
@@ -75,18 +77,17 @@ namespace armarx::armem::server::query_proc::base
});
}
- void process(ResultCoreSegmentT& result,
+ virtual void process(ResultCoreSegmentT& result,
const armem::query::data::core::Single& query,
const CoreSegmentT& coreSegment) const
{
- const ProviderSegmentT* providerSegment = coreSegment.findProviderSegment(query.providerSegmentName);
- if (providerSegment)
+ if (auto providerSegment = coreSegment.findProviderSegment(query.providerSegmentName))
{
this->_processResult(result, *providerSegment, query);
}
}
- void process(ResultCoreSegmentT& result,
+ virtual void process(ResultCoreSegmentT& result,
const armem::query::data::core::Regex& query,
const CoreSegmentT& coreSegment) const
{
@@ -102,7 +103,7 @@ namespace armarx::armem::server::query_proc::base
}
- private:
+ protected:
void _processResult(ResultCoreSegmentT& result,
const ProviderSegmentT& providerSegment,
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
index b0210c37e4ed71b64875a79453e56d928852b54f..6179467a77fa12246df6dd65c6ba9a766c5ef31f 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/EntityQueryProcessorBase.h
@@ -23,6 +23,8 @@ namespace armarx::armem::server::query_proc::base
class EntityQueryProcessorBase :
public BaseQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT, armem::query::data::EntityQuery>
{
+ protected:
+
using Base = BaseQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT, armem::query::data::EntityQuery>;
public:
@@ -34,6 +36,8 @@ namespace armarx::armem::server::query_proc::base
using ResultSnapshotT = typename ResultEntityT::EntitySnapshotT;
+ public:
+
using Base::process;
virtual void process(ResultEntityT& result,
const armem::query::data::EntityQuery& query,
@@ -74,37 +78,37 @@ namespace armarx::armem::server::query_proc::base
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::All& query,
const EntityT& entity) const
{
(void) query;
// Copy this entitiy and its contents.
- entity.forEachSnapshot([this, &result](const EntitySnapshotT & snapshot)
+ entity.forEachSnapshot([this, &result](const EntitySnapshotT& snapshot)
{
- addResultSnapshot(result, snapshot);
+ this->addResultSnapshot(result, snapshot);
});
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::Single& query,
const EntityT& entity) const
{
if (query.timestamp < 0)
{
- if (const ResultSnapshotT* snapshot = entity.findLatestSnapshot())
+ if (auto snapshot = entity.findLatestSnapshot())
{
- addResultSnapshot(result, *snapshot);
+ this->addResultSnapshot(result, *snapshot);
}
}
else
{
const Time time = fromIce<Time>(query.timestamp);
- if (const ResultSnapshotT* snapshot = entity.findSnapshot(time))
+ if (auto snapshot = entity.findSnapshot(time))
{
- addResultSnapshot(result, *snapshot);
+ this->addResultSnapshot(result, *snapshot);
}
else
{
@@ -126,7 +130,7 @@ namespace armarx::armem::server::query_proc::base
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::TimeRange& query,
const EntityT& entity) const
{
@@ -139,7 +143,7 @@ namespace armarx::armem::server::query_proc::base
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::IndexRange& query,
const EntityT& entity) const
{
@@ -147,12 +151,12 @@ namespace armarx::armem::server::query_proc::base
query.first, query.last,
[this, &result](const EntitySnapshotT & snapshot)
{
- addResultSnapshot(result, snapshot);
+ this->addResultSnapshot(result, snapshot);
});
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const Time& min,
const Time& max,
const EntityT& entity,
@@ -163,31 +167,31 @@ namespace armarx::armem::server::query_proc::base
min, max,
[this, &result](const EntitySnapshotT & snapshot)
{
- addResultSnapshot(result, snapshot);
+ this->addResultSnapshot(result, snapshot);
});
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::BeforeOrAtTime& query,
const EntityT& entity) const
{
const Time referenceTimestamp = fromIce<Time>(query.timestamp);
- detail::checkReferenceTimestampNonNegative(referenceTimestamp);
+ base::detail::checkReferenceTimestampNonNegative(referenceTimestamp);
- if (auto* beforeOrAt = entity.findLatestSnapshotBeforeOrAt(referenceTimestamp))
+ if (auto beforeOrAt = entity.findLatestSnapshotBeforeOrAt(referenceTimestamp))
{
- addResultSnapshot(result, *beforeOrAt);
+ this->addResultSnapshot(result, *beforeOrAt);
}
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::BeforeTime& query,
const EntityT& entity) const
{
const Time referenceTimestamp = fromIce<Time>(query.timestamp);
- detail::checkReferenceTimestampNonNegative(referenceTimestamp);
+ base::detail::checkReferenceTimestampNonNegative(referenceTimestamp);
std::vector<const EntitySnapshotT*> befores;
entity.forEachSnapshotBefore(referenceTimestamp, [&befores](const EntitySnapshotT & s)
@@ -208,17 +212,17 @@ namespace armarx::armem::server::query_proc::base
for (size_t r = 0; r < num; ++r)
{
size_t i = befores.size() - 1 - r;
- addResultSnapshot(result, *befores[i]);
+ this->addResultSnapshot(result, *befores[i]);
}
}
- void process(ResultEntityT& result,
+ virtual void process(ResultEntityT& result,
const armem::query::data::entity::TimeApprox& query,
const EntityT& entity) const
{
const Time referenceTimestamp = fromIce<Time>(query.timestamp);
- detail::checkReferenceTimestampNonNegative(referenceTimestamp);
+ base::detail::checkReferenceTimestampNonNegative(referenceTimestamp);
const float referenceTimestampMicroSeconds = referenceTimestamp.toMicroSeconds();
const float epsDuration = fromIce<Time>(query.eps).toMicroSeconds();
@@ -235,13 +239,13 @@ namespace armarx::armem::server::query_proc::base
};
// last element before or at timestamp
- if (auto* beforeOrAt = entity.findLatestSnapshotBeforeOrAt(referenceTimestamp))
+ if (auto beforeOrAt = entity.findLatestSnapshotBeforeOrAt(referenceTimestamp))
{
const auto timestampOfMatchBefore = beforeOrAt->id().timestamp;
const auto isPerfectMatch = timestampOfMatchBefore == referenceTimestamp;
if (isInRange(timestampOfMatchBefore))
{
- addResultSnapshot(result, *beforeOrAt);
+ this->addResultSnapshot(result, *beforeOrAt);
}
// earsly stop, not necessary to also get the next since the match is perfect
@@ -251,13 +255,13 @@ namespace armarx::armem::server::query_proc::base
}
// first element after or at timestamp (or at because of fewer checks, we can assure that there is not element at)
- const auto* after = entity.findFirstSnapshotAfterOrAt(referenceTimestamp);
+ const auto after = entity.findFirstSnapshotAfterOrAt(referenceTimestamp);
if (after)
{
const auto timestampOfMatchAfter = after->id().timestamp;
if (isInRange(timestampOfMatchAfter))
{
- addResultSnapshot(result, *after);
+ this->addResultSnapshot(result, *after);
}
}
}
@@ -266,10 +270,7 @@ namespace armarx::armem::server::query_proc::base
protected:
- void addResultSnapshot(ResultEntityT& result, const EntitySnapshotT& snapshot) const
- {
- result.addSnapshot(snapshot);
- }
+ virtual void addResultSnapshot(ResultEntityT& result, const EntitySnapshotT& snapshot) const = 0;
};
}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
index 91c41d9f54cb762654db9763dfe6d9c3af1aa60d..85d6326393bc6e4f97db4c8d4d1e26f07b8bd9b1 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/MemoryQueryProcessorBase.h
@@ -15,6 +15,8 @@ namespace armarx::armem::server::query_proc::base
class MemoryQueryProcessorBase :
public BaseQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>
{
+ protected:
+
using Base = BaseQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, armem::query::data::MemoryQuery>;
public:
@@ -67,32 +69,32 @@ namespace armarx::armem::server::query_proc::base
}
}
- void process(ResultMemoryT& result,
+ virtual void process(ResultMemoryT& result,
const armem::query::data::memory::All& query,
const MemoryT& memory) const
{
- memory.forEachCoreSegment([this, &result, &query](const CoreSegmentT & coreSegment)
+ memory.forEachCoreSegment([this, &result, &query](const CoreSegmentT& coreSegment)
{
this->_processResult(result, coreSegment, query);
});
}
- void process(ResultMemoryT& result,
+ virtual void process(ResultMemoryT& result,
const armem::query::data::memory::Single& query,
const MemoryT& memory) const
{
- if (const CoreSegmentT* coreSegment = memory.findCoreSegment(query.coreSegmentName))
+ if (auto coreSegment = memory.findCoreSegment(query.coreSegmentName))
{
this->_processResult(result, *coreSegment, query);
}
}
- void process(ResultMemoryT& result,
+ virtual void process(ResultMemoryT& result,
const armem::query::data::memory::Regex& query,
const MemoryT& memory) const
{
const std::regex regex(query.coreSegmentNameRegex);
- memory.forEachCoreSegment([this, &result, &query, ®ex](const CoreSegmentT & coreSegment)
+ memory.forEachCoreSegment([this, &result, &query, ®ex](const CoreSegmentT& coreSegment)
{
if (std::regex_search(coreSegment.name(), regex))
{
@@ -102,7 +104,7 @@ namespace armarx::armem::server::query_proc::base
}
- private:
+ protected:
void _processResult(ResultMemoryT& result,
const CoreSegmentT& coreSegment,
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
index 46f146694825936d4834b579093881e8452db3ca..bc7f92031bc7c7f940c219d226908d072e9cfe22 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/base/ProviderSegmentQueryProcessorBase.h
@@ -16,6 +16,8 @@ namespace armarx::armem::server::query_proc::base
class ProviderSegmentQueryProcessorBase :
public BaseQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>
{
+ protected:
+
using Base = BaseQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, armem::query::data::ProviderSegmentQuery>;
@@ -40,7 +42,6 @@ namespace armarx::armem::server::query_proc::base
{
}
-
using Base::process;
virtual void process(ResultProviderSegmentT& result,
const armem::query::data::ProviderSegmentQuery& query,
@@ -64,32 +65,32 @@ namespace armarx::armem::server::query_proc::base
}
}
- void process(ResultProviderSegmentT& result,
+ virtual void process(ResultProviderSegmentT& result,
const armem::query::data::provider::All& query,
const ProviderSegmentT& providerSegment) const
{
- providerSegment.forEachEntity([this, &result, &query](const EntityT & entity)
+ providerSegment.forEachEntity([this, &result, &query](const EntityT& entity)
{
this->_processResult(result, entity, query);
});
}
- void process(ResultProviderSegmentT& result,
+ virtual void process(ResultProviderSegmentT& result,
const armem::query::data::provider::Single& query,
const ProviderSegmentT& providerSegment) const
{
- if (const EntityT* entity = providerSegment.findEntity(query.entityName))
+ if (auto entity = providerSegment.findEntity(query.entityName))
{
this->_processResult(result, *entity, query);
}
}
- void process(ResultProviderSegmentT& result,
+ virtual void process(ResultProviderSegmentT& result,
const armem::query::data::provider::Regex& query,
const ProviderSegmentT& providerSegment) const
{
const std::regex regex(query.entityNameRegex);
- providerSegment.forEachEntity([this, &result, &query, ®ex](const EntityT & entity)
+ providerSegment.forEachEntity([this, &result, &query, ®ex](const EntityT& entity)
{
if (std::regex_search(entity.name(), regex))
{
@@ -100,7 +101,7 @@ namespace armarx::armem::server::query_proc::base
}
- private:
+ protected:
void _processResult(ResultProviderSegmentT& result,
const EntityT& entity,
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm.cpp
deleted file mode 100644
index 238cc4b8d1601bf1ffae131caabbf8ca8435899a..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "ltm.h"
-
-
-namespace armarx::armem::server::query_proc::ltm
-{
-}
-
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm.h
deleted file mode 100644
index 05734c2e15d6836b69719283805fcfc5c1d7702d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-
-#include <RobotAPI/libraries/armem/server/ltm/LongtermMemoryBase.h>
-#include <RobotAPI/libraries/armem/server/query_proc/base.h>
-
-
-namespace armarx::armem::server::query_proc::ltm
-{
- static const base::QueryTarget queryTarget = query::data::QueryTarget::LTM;
-
-
- class EntityQueryProcessor :
- public base::EntityQueryProcessorBase<queryTarget, armem::wm::Entity, armem::wm::Entity>
- {
- };
-
- class ProviderSegmentQueryProcessor :
- public base::ProviderSegmentQueryProcessorBase <queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor >
- {
- };
-
- class CoreSegmentQueryProcessor :
- public base::CoreSegmentQueryProcessorBase <queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>
- {
- };
-
- class MemoryQueryProcessor :
- public base::MemoryQueryProcessorBase <queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor >
- {
- };
-
-}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..63e7ff349207a6891d26c0dde081572f0e53d3a5
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.cpp
@@ -0,0 +1 @@
+#include "CoreSegmentQueryProcessorBase.h"
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f06af9dad98fb9e732710cd03bfe95661e286ed
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/CoreSegmentQueryProcessorBase.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "../../base/CoreSegmentQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::ltm::detail
+{
+
+ /**
+ * @brief Handles memory queries.
+ */
+ template <base::QueryTarget queryTarget, class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
+ class CoreSegmentQueryProcessorBase :
+ public base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
+
+
+ public:
+ using CoreSegmentT = typename Base::CoreSegmentT;
+ using ProviderSegmentT = typename Base::ProviderSegmentT;
+ using ResultCoreSegmentT = typename Base::ResultCoreSegmentT;
+ using ResultProviderSegmentT = typename Base::ProviderSegmentT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+ public:
+ using Base::CoreSegmentQueryProcessorBase;
+ virtual ~CoreSegmentQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e01bbbf5a0d6862f75d245fef36d42e752ad42ef
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.cpp
@@ -0,0 +1,9 @@
+#include "EntityQueryProcessorBase.h"
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+
+namespace armarx::armem::server::query_proc::base
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0be62d216464c0b04a167c9f71ae62543cf6086
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "../../base/EntityQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::ltm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _EntityT, class _ResultEntityT>
+ class EntityQueryProcessorBase :
+ public base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>
+ {
+ protected:
+
+ using Base = base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>;
+
+ public:
+ using EntityT = typename Base::EntityT;
+ using EntitySnapshotT = typename Base::EntitySnapshotT;
+ using ResultEntityT = typename Base::ResultEntityT;
+ using ResultSnapshotT = typename Base::ResultSnapshotT;
+
+ public:
+ virtual ~EntityQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ protected:
+ void addResultSnapshot(ResultEntityT& result, const EntitySnapshotT& snapshot) const override
+ {
+ ResultSnapshotT s;
+ snapshot.loadAll(s);
+ result.addSnapshot(s);
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c51a6336c440e44fe637df89700136687d03f294
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.cpp
@@ -0,0 +1 @@
+#include "MemoryQueryProcessorBase.h"
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..a077de9ca046fde8910d9f174d90dddfd510d00c
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/MemoryQueryProcessorBase.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "../../base/MemoryQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::ltm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
+ class MemoryQueryProcessorBase :
+ public base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>;
+
+ public:
+
+ using MemoryT = typename Base::MemoryT;
+ using CoreSegmentT = typename Base::CoreSegmentT;
+ using ResultMemoryT = typename Base::ResultMemoryT;
+ using ResultCoreSegmentT = typename Base::CoreSegmentT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+ public:
+ using Base::MemoryQueryProcessorBase;
+ virtual ~MemoryQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..67db9e1429d8aa9c797790f4290a9feb512d41c6
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.cpp
@@ -0,0 +1 @@
+#include "ProviderSegmentQueryProcessorBase.h"
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3512921d7100819f751e18b793508bbebc85436
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/ProviderSegmentQueryProcessorBase.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "../../base/ProviderSegmentQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::ltm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
+ class ProviderSegmentQueryProcessorBase :
+ public base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
+
+ public:
+
+ using ProviderSegmentT = typename Base::ProviderSegmentT;
+ using EntityT = typename Base::EntityT;
+ using ResultProviderSegmentT = typename Base::ResultProviderSegmentT;
+ using ResultEntityT = typename Base::EntityT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+ public:
+ using Base::ProviderSegmentQueryProcessorBase;
+ virtual ~ProviderSegmentQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.cpp b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf48f8897c8b04b35a14086ae6cc93aed2f1b5cb
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.cpp
@@ -0,0 +1,7 @@
+#include "ltm.h"
+
+
+namespace armarx::armem::server::query_proc::ltm_server::disk
+{
+}
+
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h
new file mode 100644
index 0000000000000000000000000000000000000000..80d83a15c4f537916c61049efc27016f48f7eb31
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <RobotAPI/libraries/armem/server/ltm/disk/Memory.h>
+#include <RobotAPI/libraries/armem/server/query_proc/base.h>
+
+#include "../detail/MemoryQueryProcessorBase.h"
+#include "../detail/CoreSegmentQueryProcessorBase.h"
+#include "../detail/ProviderSegmentQueryProcessorBase.h"
+#include "../detail/EntityQueryProcessorBase.h"
+
+namespace armarx::armem::server::query_proc::ltm_server::disk
+{
+ static const base::QueryTarget queryTarget = query::data::QueryTarget::LTM;
+
+
+ class EntityQueryProcessor :
+ public ltm::detail::EntityQueryProcessorBase<queryTarget, armem::server::ltm::disk::Entity, armem::wm::Entity>
+ {
+ protected:
+
+ using Base = ltm::detail::EntityQueryProcessorBase<queryTarget, armem::server::ltm::disk::Entity, armem::wm::Entity>;
+
+
+ public:
+
+ using Base::process;
+
+ };
+
+ class ProviderSegmentQueryProcessor :
+ public ltm::detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>
+ {
+ protected:
+
+ using Base = ltm::detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+
+
+ public:
+ using Base::process;
+ };
+
+ class CoreSegmentQueryProcessor :
+ public ltm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>
+ {
+ protected:
+
+ using Base = ltm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::server::ltm::disk::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+
+
+ public:
+ using Base::process;
+ };
+
+ class MemoryQueryProcessor :
+ public ltm::detail::MemoryQueryProcessorBase<queryTarget, armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>
+ {
+ protected:
+
+ using Base = ltm::detail::MemoryQueryProcessorBase<queryTarget, armem::server::ltm::disk::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+
+ public:
+ using Base::process;
+ };
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..477263258cc7939df0170ae3057a8b957bd2f421
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.cpp
@@ -0,0 +1,6 @@
+#include "CoreSegmentQueryProcessorBase.h"
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9a0ddb51227f9ac5ab98c695105bd82ba99652e
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/CoreSegmentQueryProcessorBase.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "../../base/CoreSegmentQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+ /**
+ * @brief Handles memory queries.
+ */
+ template <base::QueryTarget queryTarget, class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
+ class CoreSegmentQueryProcessorBase :
+ public base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::CoreSegmentQueryProcessorBase<queryTarget, _CoreSegmentT, _ResultCoreSegmentT, _ChildProcessorT>;
+
+
+ public:
+
+ using CoreSegmentT = typename Base::CoreSegmentT;
+ using ProviderSegmentT = typename Base::ProviderSegmentT;
+ using ResultCoreSegmentT = typename Base::ResultCoreSegmentT;
+ using ResultProviderSegmentT = typename Base::ProviderSegmentT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+
+ public:
+
+ using Base::CoreSegmentQueryProcessorBase;
+ virtual ~CoreSegmentQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c5923363004f6b036e5d4756731687bbe96f82b9
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.cpp
@@ -0,0 +1,9 @@
+#include "EntityQueryProcessorBase.h"
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..a107d615518d9fbaf700b15992aacda95f00c839
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/EntityQueryProcessorBase.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "../../base/EntityQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _EntityT, class _ResultEntityT>
+ class EntityQueryProcessorBase :
+ public base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>
+ {
+ protected:
+
+ using Base = base::EntityQueryProcessorBase<queryTarget, _EntityT, _ResultEntityT>;
+
+
+ public:
+
+ using EntityT = typename Base::EntityT;
+ using EntitySnapshotT = typename Base::EntitySnapshotT;
+ using ResultEntityT = typename Base::ResultEntityT;
+ using ResultSnapshotT = typename Base::EntitySnapshotT;
+
+
+ public:
+ virtual ~EntityQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ protected:
+ void addResultSnapshot(ResultEntityT& result, const EntitySnapshotT& snapshot) const override
+ {
+ result.addSnapshot(snapshot);
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f72b60033120b639668c3b7b38790df91a671ec6
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.cpp
@@ -0,0 +1,7 @@
+#include "MemoryQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..38d7a9ec403df90590e6eea1c45db5c757097dce
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/MemoryQueryProcessorBase.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "../../base/MemoryQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _MemoryT, class _ResultMemoryT, class _ChildProcessorT>
+ class MemoryQueryProcessorBase :
+ public base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::MemoryQueryProcessorBase<queryTarget, _MemoryT, _ResultMemoryT, _ChildProcessorT>;
+
+
+ public:
+
+ using MemoryT = typename Base::MemoryT;
+ using CoreSegmentT = typename Base::CoreSegmentT;
+ using ResultMemoryT = typename Base::ResultMemoryT;
+ using ResultCoreSegmentT = typename Base::CoreSegmentT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+
+ public:
+ using Base::MemoryQueryProcessorBase;
+ virtual ~MemoryQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d11b94bcde069c67740d12ab79e00a5ad7bc6afe
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.cpp
@@ -0,0 +1,6 @@
+#include "ProviderSegmentQueryProcessorBase.h"
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
new file mode 100644
index 0000000000000000000000000000000000000000..759938b2b6fbf8c2d650d47f9820233f662a6070
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/detail/ProviderSegmentQueryProcessorBase.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "../../base/ProviderSegmentQueryProcessorBase.h"
+
+
+namespace armarx::armem::server::query_proc::wm::detail
+{
+
+ template <base::QueryTarget queryTarget, class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
+ class ProviderSegmentQueryProcessorBase :
+ public base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>
+ {
+ protected:
+
+ using Base = base::ProviderSegmentQueryProcessorBase<queryTarget, _ProviderSegmentT, _ResultProviderSegmentT, _ChildProcessorT>;
+
+
+ public:
+
+ using ProviderSegmentT = typename Base::ProviderSegmentT;
+ using EntityT = typename Base::EntityT;
+ using ResultProviderSegmentT = typename Base::ResultProviderSegmentT;
+ using ResultEntityT = typename Base::EntityT;
+ using ChildProcessorT = typename Base::ChildProcessorT;
+
+
+ public:
+ using Base::ProviderSegmentQueryProcessorBase;
+ virtual ~ProviderSegmentQueryProcessorBase() = default;
+
+ using Base::process;
+
+
+ };
+}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm.cpp b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
similarity index 89%
rename from source/RobotAPI/libraries/armem/server/query_proc/wm.cpp
rename to source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
index 0ace705be878087b9023ea574f50769489514cb5..b8d25db27074f2033fd2791aa9aca787607d8da5 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm.cpp
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.cpp
@@ -16,7 +16,8 @@ namespace armarx::armem::server::query_proc::wm
{
ProviderSegmentQueryProcessor::ProviderSegmentQueryProcessor(DataMode dataMode) :
- ProviderSegmentQueryProcessorBase(dataMode), HasDataMode(dataMode)
+ detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>(dataMode),
+ HasDataMode(dataMode)
{
}
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/wm.h b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
similarity index 54%
rename from source/RobotAPI/libraries/armem/server/query_proc/wm.h
rename to source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
index aa52b4ab22fe1c6ef194ef37d4e38f5c7720d6c5..2d1ff3e351f019f0eb18eed7b143b15497b1f015 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/wm.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/wm/wm.h
@@ -3,7 +3,11 @@
#include <RobotAPI/libraries/armem/core/DataMode.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-#include <RobotAPI/libraries/armem/server/query_proc/base.h>
+
+#include "detail/MemoryQueryProcessorBase.h"
+#include "detail/CoreSegmentQueryProcessorBase.h"
+#include "detail/ProviderSegmentQueryProcessorBase.h"
+#include "detail/EntityQueryProcessorBase.h"
namespace armarx::armem::server::query_proc::wm
@@ -30,15 +34,22 @@ namespace armarx::armem::server::query_proc::wm::detail
template <class SourceEntityT>
class EntityQueryProcessor :
- public base::EntityQueryProcessorBase<queryTarget, SourceEntityT, armem::wm::Entity>,
+ public EntityQueryProcessorBase<queryTarget, SourceEntityT, armem::wm::Entity>,
public HasDataMode
{
+ protected:
+
+ using Base = EntityQueryProcessorBase<queryTarget, SourceEntityT, armem::wm::Entity>;
+ using Entity = armem::wm::Entity;
+
+
public:
EntityQueryProcessor(DataMode dataMode = DataMode::WithData) :
HasDataMode(dataMode)
{}
+ using Base::process;
protected:
@@ -70,41 +81,62 @@ namespace armarx::armem::server::query_proc::wm
using EntityQueryProcessor = detail::EntityQueryProcessor<armem::wm::Entity>;
-
class ProviderSegmentQueryProcessor :
- public base::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor >,
+ public detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
public detail::HasDataMode
{
+ protected:
+
+ using Base = detail::ProviderSegmentQueryProcessorBase<queryTarget, armem::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+ using ProviderSegment = armem::wm::ProviderSegment;
+ using Entity = armem::wm::Entity;
+
+
public:
ProviderSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+ using Base::process;
};
class CoreSegmentQueryProcessor :
- public base::CoreSegmentQueryProcessorBase <queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor >,
+ public detail::CoreSegmentQueryProcessorBase <queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
public detail::HasDataMode
{
- using Base = base::CoreSegmentQueryProcessorBase<queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+ protected:
+
+ using Base = wm::detail::CoreSegmentQueryProcessorBase<queryTarget, armem::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
using CoreSegment = armem::wm::CoreSegment;
using ProviderSegment = armem::wm::ProviderSegment;
+
public:
CoreSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
+ using Base::process;
+
};
class MemoryQueryProcessor :
- public base::MemoryQueryProcessorBase<queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
+ public detail::MemoryQueryProcessorBase<queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
public detail::HasDataMode
{
+ protected:
+
+ using Base = detail::MemoryQueryProcessorBase<queryTarget, armem::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+ using Memory = armem::wm::Memory;
+ using CoreSegment = armem::wm::CoreSegment;
+
+
public:
MemoryQueryProcessor(DataMode dataMode = DataMode::WithData);
+ using Base::process;
+
};
}
@@ -117,9 +149,15 @@ namespace armarx::armem::server::query_proc::wm_server
class ProviderSegmentQueryProcessor :
- public base::ProviderSegmentQueryProcessorBase<wm::queryTarget, server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor >,
+ public wm::detail::ProviderSegmentQueryProcessorBase<wm::queryTarget, server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>,
public wm::detail::HasDataMode
{
+ protected:
+
+ using Base = wm::detail::ProviderSegmentQueryProcessorBase<wm::queryTarget, server::wm::ProviderSegment, armem::wm::ProviderSegment, EntityQueryProcessor>;
+ using ProviderSegment = server::wm::ProviderSegment;
+ using Entity = server::wm::Entity;
+
public:
ProviderSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
@@ -128,18 +166,20 @@ namespace armarx::armem::server::query_proc::wm_server
class CoreSegmentQueryProcessor :
- public base::CoreSegmentQueryProcessorBase <wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor >,
+ public wm::detail::CoreSegmentQueryProcessorBase <wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>,
public wm::detail::HasDataMode
{
- using Base = base::CoreSegmentQueryProcessorBase<wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
+ protected:
+
+ using Base = wm::detail::CoreSegmentQueryProcessorBase<wm::queryTarget, server::wm::CoreSegment, armem::wm::CoreSegment, ProviderSegmentQueryProcessor>;
using CoreSegment = server::wm::CoreSegment;
using ProviderSegment = server::wm::ProviderSegment;
+
public:
CoreSegmentQueryProcessor(DataMode dataMode = DataMode::WithData);
-
using Base::process;
/// Locks the core segment, then delegates back to `CoreSegmentQueryProcessorBase`.
@@ -152,13 +192,21 @@ namespace armarx::armem::server::query_proc::wm_server
class MemoryQueryProcessor :
- public base::MemoryQueryProcessorBase<wm::queryTarget, server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
+ public wm::detail::MemoryQueryProcessorBase<wm::queryTarget, server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>,
public wm::detail::HasDataMode
{
+ protected:
+
+ using Base = wm::detail::MemoryQueryProcessorBase<wm::queryTarget, server::wm::Memory, armem::wm::Memory, CoreSegmentQueryProcessor>;
+ using Memory = server::wm::Memory;
+ using CoreSegment = server::wm::CoreSegment;
+
public:
MemoryQueryProcessor(DataMode dataMode = DataMode::WithData);
+ using Base::process;
+
};
}
diff --git a/source/RobotAPI/libraries/armem/server/segment/Segment.cpp b/source/RobotAPI/libraries/armem/server/segment/Segment.cpp
index d538568c2430c9ffbd00c9b48bebcd46086280ea..4e477fd51a0271cc905f3e6e4dfa538b80ada9d5 100644
--- a/source/RobotAPI/libraries/armem/server/segment/Segment.cpp
+++ b/source/RobotAPI/libraries/armem/server/segment/Segment.cpp
@@ -3,7 +3,7 @@
#include <ArmarXCore/core/application/properties/PluginAll.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
@@ -13,7 +13,7 @@ namespace armarx::armem::server::segment
wm::CoreSegmentBase::CoreSegmentBase(
armem::server::MemoryToIceAdapter& iceMemory,
const std::string& defaultCoreSegmentName,
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType,
+ aron::type::ObjectPtr coreSegmentAronType,
int defaultMaxHistorySize) :
Base(iceMemory),
p({defaultCoreSegmentName, defaultMaxHistorySize}),
@@ -51,9 +51,9 @@ namespace armarx::armem::server::segment
wm::ProviderSegmentBase::ProviderSegmentBase(
armem::server::MemoryToIceAdapter& iceMemory,
const std::string& defaultProviderSegmentName,
- aron::typenavigator::ObjectNavigatorPtr providerSegmentAronType,
+ aron::type::ObjectPtr providerSegmentAronType,
const std::string& defaultCoreSegmentName,
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType,
+ aron::type::ObjectPtr coreSegmentAronType,
int defaultMaxHistorySize) :
Base(iceMemory),
diff --git a/source/RobotAPI/libraries/armem/server/segment/Segment.h b/source/RobotAPI/libraries/armem/server/segment/Segment.h
index dc35846aa89d14c125e5a6f3093e1a19ee85c6e2..2ea3000633d9e0b9c9957626e15efc2e5bd54003 100644
--- a/source/RobotAPI/libraries/armem/server/segment/Segment.h
+++ b/source/RobotAPI/libraries/armem/server/segment/Segment.h
@@ -3,7 +3,7 @@
#include <RobotAPI/libraries/armem/server/forward_declarations.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/type/variant/forward_declarations.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/application/properties/forward_declarations.h>
@@ -64,7 +64,7 @@ namespace armarx::armem::server::segment
CoreSegmentBase(
MemoryToIceAdapter& iceMemory,
const std::string& defaultCoreSegmentName = "",
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType = nullptr,
+ aron::type::ObjectPtr coreSegmentAronType = nullptr,
int defaultMaxHistorySize = -1);
virtual ~CoreSegmentBase() override;
@@ -91,7 +91,7 @@ namespace armarx::armem::server::segment
};
Properties p;
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType;
+ aron::type::ObjectPtr coreSegmentAronType;
};
@@ -108,9 +108,9 @@ namespace armarx::armem::server::segment
ProviderSegmentBase(
MemoryToIceAdapter& iceMemory,
const std::string& defaultProviderSegmentName = "",
- aron::typenavigator::ObjectNavigatorPtr providerSegmentAronType = nullptr,
+ aron::type::ObjectPtr providerSegmentAronType = nullptr,
const std::string& defaultCoreSegmentName = "",
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType = nullptr,
+ aron::type::ObjectPtr coreSegmentAronType = nullptr,
int defaultMaxHistorySize = -1);
virtual ~ProviderSegmentBase() override;
@@ -131,8 +131,8 @@ namespace armarx::armem::server::segment
};
Properties p;
- aron::typenavigator::ObjectNavigatorPtr coreSegmentAronType;
- aron::typenavigator::ObjectNavigatorPtr providerSegmentAronType;
+ aron::type::ObjectPtr coreSegmentAronType;
+ aron::type::ObjectPtr providerSegmentAronType;
server::wm::CoreSegment* coreSegment;
};
diff --git a/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.cpp b/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.cpp
index 50f5ae6451bb49f9a4356579d78618a865297881..47e8343c218715bf9509df7ce9463ea226efaf42 100644
--- a/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.cpp
@@ -4,7 +4,7 @@
#include <ArmarXCore/core/application/properties/PluginAll.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
@@ -13,7 +13,7 @@ namespace armarx::armem::server::segment
SpecializedSegment::SpecializedSegment(
server::MemoryToIceAdapter& iceMemory,
- aron::typenavigator::ObjectNavigatorPtr aronType,
+ aron::type::ObjectPtr aronType,
const std::string& defaultCoreSegmentName,
int64_t defaultMaxHistorySize
) :
@@ -64,7 +64,7 @@ namespace armarx::armem::server::segment
}
- void SpecializedSegment::setAronType(aron::typenavigator::ObjectNavigatorPtr aronType)
+ void SpecializedSegment::setAronType(aron::type::ObjectPtr aronType)
{
this->aronType = aronType;
}
diff --git a/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.h b/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.h
index 271536db21ffdfadb3fba874f60bdd8a33d21f44..f03598e94c75af19f3922e1b383ebf0ace5b6320 100644
--- a/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.h
+++ b/source/RobotAPI/libraries/armem/server/segment/SpecializedSegment.h
@@ -2,7 +2,7 @@
#include <RobotAPI/libraries/armem/server/forward_declarations.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/type/variant/forward_declarations.h>
#include <ArmarXCore/core/application/properties/forward_declarations.h>
#include <ArmarXCore/core/logging/Logging.h>
@@ -23,7 +23,7 @@ namespace armarx::armem::server::segment
SpecializedSegment(
server::MemoryToIceAdapter& iceMemory,
- aron::typenavigator::ObjectNavigatorPtr aronType = nullptr,
+ aron::type::ObjectPtr aronType = nullptr,
const std::string& defaultCoreSegmentName = "",
int64_t defaultMaxHistorySize = -1);
@@ -46,14 +46,14 @@ namespace armarx::armem::server::segment
void setDefaultCoreSegmentName(const std::string& coreSegmentName);
void setDefaultMaxHistorySize(int64_t maxHistorySize);
- void setAronType(aron::typenavigator::ObjectNavigatorPtr aronType);
+ void setAronType(aron::type::ObjectPtr aronType);
protected:
server::MemoryToIceAdapter& iceMemory;
server::wm::CoreSegment* coreSegment = nullptr;
- aron::typenavigator::ObjectNavigatorPtr aronType;
+ aron::type::ObjectPtr aronType;
struct Properties
{
diff --git a/source/RobotAPI/libraries/armem/server/wm/memory_definitions.cpp b/source/RobotAPI/libraries/armem/server/wm/memory_definitions.cpp
index c2dc4f6b38abdd3de9e67afe0f7031f2209d2055..35da4691d69dcb4a0290d84f19098608b7d3aab6 100644
--- a/source/RobotAPI/libraries/armem/server/wm/memory_definitions.cpp
+++ b/source/RobotAPI/libraries/armem/server/wm/memory_definitions.cpp
@@ -2,7 +2,7 @@
#include "error.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <map>
diff --git a/source/RobotAPI/libraries/armem/server/wm/memory_definitions.h b/source/RobotAPI/libraries/armem/server/wm/memory_definitions.h
index 029d185c62445a5a83dd749d1b86f2393f95e6d2..e6889b7f8e0a6b40f16d28ad2bcc05f68250b1a5 100644
--- a/source/RobotAPI/libraries/armem/server/wm/memory_definitions.h
+++ b/source/RobotAPI/libraries/armem/server/wm/memory_definitions.h
@@ -18,8 +18,8 @@
namespace armarx::armem::server::wm
{
using EntityInstanceMetadata = base::EntityInstanceMetadata;
- using EntityInstanceData = armarx::aron::datanavigator::DictNavigator;
- using EntityInstanceDataPtr = armarx::aron::datanavigator::DictNavigatorPtr;
+ using EntityInstanceData = armarx::aron::data::Dict;
+ using EntityInstanceDataPtr = armarx::aron::data::DictPtr;
using EntityInstance = armem::wm::EntityInstance;
using EntitySnapshot = armem::wm::EntitySnapshot;
diff --git a/source/RobotAPI/libraries/armem/test/ArMemLTMBenchmark.cpp b/source/RobotAPI/libraries/armem/test/ArMemLTMBenchmark.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4965373da2d7c3443b5748e133e62607b1a198c
--- /dev/null
+++ b/source/RobotAPI/libraries/armem/test/ArMemLTMBenchmark.cpp
@@ -0,0 +1,115 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @package RobotAPI::ArmarXObjects::armem
+ * @author Simon Ottenhaus ( simon dot ottenhaus at kit dot edu )
+ * @date 2020
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#define BOOST_TEST_MODULE RobotAPI::ArmarXLibraries::armem
+
+#define ARMARX_BOOST_TEST
+
+#include <RobotAPI/Test.h>
+#include <RobotAPI/libraries/armem/server/ltm/disk/Memory.h>
+#include <RobotAPI/libraries/armem/core/error.h>
+
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+#include <ArmarXCore/core/time/StopWatch.h>
+
+
+#include <filesystem>
+#include <iostream>
+
+namespace armem = armarx::armem;
+namespace aron = armarx::aron;
+namespace fs = std::filesystem;
+
+namespace ArMemLTMBenchmark
+{
+ struct Fixture
+ {
+ fs::path storagePath = "/tmp/MemoryExport";
+
+ Fixture()
+ {
+ clearStoragePath();
+ }
+ ~Fixture()
+ {
+ //clearStoragePath();
+ }
+
+ void clearStoragePath()
+ {
+ if (fs::exists(storagePath))
+ {
+ fs::remove_all(storagePath);
+ }
+ BOOST_TEST_INFO("Storage path: " << storagePath);
+ BOOST_REQUIRE(!fs::exists(storagePath));
+ }
+
+ void storeElementNTimes(const std::string& memoryName, const aron::data::DictPtr& dict, int waitingTimeMs, int n)
+ {
+ armem::server::ltm::disk::Memory ltm;
+ ltm.setPath(storagePath / memoryName);
+ ltm.setMemoryID(ltm.id().withMemoryName(memoryName));
+
+ armem::wm::Memory wm(memoryName);
+ auto& core = wm.addCoreSegment("CoreS");
+ auto& prov = core.addProviderSegment("ProvS");
+ auto& en = prov.addEntity("EntityS");
+
+ for (int i = 0; i < n; ++i)
+ {
+ std::cout << "Store instance " << i << " of memory " << memoryName << std::endl;
+
+ en.clear();
+ auto& snap = en.addSnapshot(IceUtil::Time::now());
+ auto& ins = snap.addInstance();
+ auto cloned = aron::data::Dict::DynamicCastAndCheck(dict->clone());
+ ins.data() = cloned;
+
+ ltm.store(wm);
+ ltm.storeBuffer();
+
+ usleep(waitingTimeMs * 1000.0);
+ }
+ }
+ };
+}
+
+BOOST_FIXTURE_TEST_SUITE(ArMemLTMBenchmark, Fixture)
+
+
+BOOST_AUTO_TEST_CASE(test_memory_export__single_image_benchmark)
+{
+ auto data = std::make_shared<aron::data::Dict>();
+
+ std::vector<int> dimensions = {720, 1280, 3};
+ std::string type = "16";
+ std::vector<unsigned char> d(720*1280*3, 255);
+ data->addElement("image", std::make_shared<aron::data::NDArray>(dimensions, type, d));
+
+ storeElementNTimes("SingleImageBenchmark", data, 100, 2);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
diff --git a/source/RobotAPI/libraries/armem/test/ArMemLTMTest.cpp b/source/RobotAPI/libraries/armem/test/ArMemLTMTest.cpp
index f0ede7b42a3bdb34d1a103ab43226adae833740a..85096741e92f5ede902cdd55879545476cb3facd 100644
--- a/source/RobotAPI/libraries/armem/test/ArMemLTMTest.cpp
+++ b/source/RobotAPI/libraries/armem/test/ArMemLTMTest.cpp
@@ -28,11 +28,8 @@
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
#include <RobotAPI/libraries/armem/core/error.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/Randomizer.h>
-
-#include <RobotAPI/libraries/aron/core/Debug.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
//#include "../core/io/diskWriter/NlohmannJSON/NlohmannJSONDiskWriter.h"
@@ -83,12 +80,12 @@ namespace ArMemLTMTest
static armem::wm::Memory setupMemoryWithType(
const std::string& memoryName,
- const aron::typenavigator::ObjectNavigatorPtr& t1,
- const aron::typenavigator::ObjectNavigatorPtr& t2,
+ const aron::type::ObjectPtr& t1,
+ const aron::type::ObjectPtr& t2,
unsigned int numSnapshots,
unsigned int numInstances)
{
- aron::Randomizer r;
+ /*aron::Randomizer r;
armem::wm::Memory memory(memoryName);
BOOST_CHECK_EQUAL(memory.name(), memoryName);
@@ -104,16 +101,16 @@ namespace ArMemLTMTest
//coreSegment.aronType() = t1;
//providerSegment.aronType() = t2;
- aron::typenavigator::ObjectNavigatorPtr t = t2 != nullptr ? t2 : t1;
+ aron::type::ObjectPtr t = t2 != nullptr ? t2 : t1;
for (unsigned int i = 0; i < numSnapshots; ++i)
{
armem::EntityUpdate update;
- std::vector<aron::datanavigator::DictNavigatorPtr> q;
+ std::vector<aron::data::DictPtr> q;
for (unsigned int j = 0; j < numInstances; ++j)
{
- aron::datanavigator::DictNavigatorPtr m = aron::datanavigator::DictNavigator::DynamicCastAndCheck(r.generateEmptyAronDataFromType(t));
+ aron::data::DictPtr m = aron::data::Dict::DynamicCastAndCheck(r.generateEmptyAronDataFromType(t));
r.initializeRandomly(m, t);
q.push_back(m);
}
@@ -125,13 +122,14 @@ namespace ArMemLTMTest
}
BOOST_CHECK(providerSegment.hasEntity("TestEntity"));
- return memory;
+ return memory;*/
+ return {};
}
template <class TypeNavigatorT>
- aron::typenavigator::ObjectNavigatorPtr makeType(const std::string& memberPrefix, int numMembers = 4)
+ aron::type::ObjectPtr makeType(const std::string& memberPrefix, int numMembers = 4)
{
- aron::typenavigator::ObjectNavigatorPtr t = std::make_shared<aron::typenavigator::ObjectNavigator>(aron::Path());
+ /*aron::type::ObjectPtr t = std::make_shared<aron::type::Object>(aron::Path());
t->setObjectName("TestObjectType1");
for (int i = 0; i < numMembers; ++i)
@@ -139,7 +137,8 @@ namespace ArMemLTMTest
t->addMemberType(memberPrefix + std::to_string(i + 1), std::make_shared<TypeNavigatorT>());
}
- return t;
+ return t;*/
+ return nullptr;
}
template <class TypeNavigatorT>
@@ -178,32 +177,32 @@ BOOST_FIXTURE_TEST_SUITE(ArMemLTMTest, Fixture)
BOOST_AUTO_TEST_CASE(test_memory_export__easy_int_setup)
{
- run<aron::typenavigator::IntNavigator>("TestMemory_IntSetup", "theInt");
+ run<aron::type::Int>("TestMemory_IntSetup", "theInt");
}
BOOST_AUTO_TEST_CASE(test_memory_export__easy_long_setup)
{
- run<aron::typenavigator::LongNavigator>("TestMemory_LongSetup", "theLong");
+ run<aron::type::Long>("TestMemory_LongSetup", "theLong");
}
BOOST_AUTO_TEST_CASE(test_memory_export__easy_float_setup)
{
- run<aron::typenavigator::FloatNavigator>("TestMemory_FloatSetup", "theFloat");
+ run<aron::type::Float>("TestMemory_FloatSetup", "theFloat");
}
BOOST_AUTO_TEST_CASE(test_memory_export__easy_double_setup)
{
- run<aron::typenavigator::DoubleNavigator>("TestMemory_DoubleSetup", "theDouble");
+ run<aron::type::Double>("TestMemory_DoubleSetup", "theDouble");
}
BOOST_AUTO_TEST_CASE(test_memory_export__easy_string_setup)
{
- run<aron::typenavigator::StringNavigator>("TestMemory_StringSetup", "theString");
+ run<aron::type::String>("TestMemory_StringSetup", "theString");
}
BOOST_AUTO_TEST_CASE(test_memory_export__easy_bool_setup)
{
- run<aron::typenavigator::BoolNavigator>("TestMemory_BoolSetup", "theBool");
+ run<aron::type::Bool>("TestMemory_BoolSetup", "theBool");
}
/*
diff --git a/source/RobotAPI/libraries/armem/test/ArMemMemoryTest.cpp b/source/RobotAPI/libraries/armem/test/ArMemMemoryTest.cpp
index e9f694a27104c142603752f22f5452c8024663b0..1fb8c6341adea6866181779d2e1cb43b26296cc6 100644
--- a/source/RobotAPI/libraries/armem/test/ArMemMemoryTest.cpp
+++ b/source/RobotAPI/libraries/armem/test/ArMemMemoryTest.cpp
@@ -33,8 +33,8 @@
#include <iostream>
#include <SimoxUtility/meta/type_name.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
namespace armem = armarx::armem;
@@ -664,7 +664,8 @@ struct CopyMoveCtorsOpsTest : public CopyMoveCtorsOpsTestBase
if constexpr(std::is_base_of_v <armarx::armem::base::detail::AronTyped, T>)
{
- in.aronType() = std::make_shared<aron::typenavigator::ObjectNavigator>();
+
+ in.aronType() = std::make_shared<aron::type::Object>("some_object", std::map<std::string, aron::type::VariantPtr>());
BOOST_CHECK(in.aronType());
}
}
@@ -811,8 +812,8 @@ BOOST_AUTO_TEST_CASE(test_segment_setup)
update.entityID = armem::MemoryID::fromString("Memory/ImageRGB/SomeRGBImageProvider/image");
update.instancesData =
{
- std::make_shared<aron::datanavigator::DictNavigator>(),
- std::make_shared<aron::datanavigator::DictNavigator>()
+ std::make_shared<aron::data::Dict>(),
+ std::make_shared<aron::data::Dict>()
};
update.timeCreated = armem::Time::milliSeconds(1000);
BOOST_CHECK_NO_THROW(providerSegment.update(update));
@@ -832,7 +833,7 @@ BOOST_AUTO_TEST_CASE(test_segment_setup)
// Another update (on memory).
- update.instancesData = { std::make_shared<aron::datanavigator::DictNavigator>() };
+ update.instancesData = { std::make_shared<aron::data::Dict>() };
update.timeCreated = armem::Time::milliSeconds(2000);
memory.update(update);
BOOST_CHECK_EQUAL(entity.size(), 2);
@@ -841,7 +842,7 @@ BOOST_AUTO_TEST_CASE(test_segment_setup)
// A third update (on entity).
- update.instancesData = { std::make_shared<aron::datanavigator::DictNavigator>() };
+ update.instancesData = { std::make_shared<aron::data::Dict>() };
update.timeCreated = armem::Time::milliSeconds(3000);
entity.update(update);
BOOST_CHECK_EQUAL(entity.size(), 3);
diff --git a/source/RobotAPI/libraries/armem/test/ArMemQueryTest.cpp b/source/RobotAPI/libraries/armem/test/ArMemQueryTest.cpp
index 13d050572342263d273dc5080f1631cec15faf05..191cfb6256257006a27bcd46bd25667e0d8b1bb8 100644
--- a/source/RobotAPI/libraries/armem/test/ArMemQueryTest.cpp
+++ b/source/RobotAPI/libraries/armem/test/ArMemQueryTest.cpp
@@ -28,7 +28,7 @@
#include <RobotAPI/interface/armem/query.h>
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/core/base/detail/negative_index_semantics.h>
-#include <RobotAPI/libraries/armem/server/query_proc/wm.h>
+#include <RobotAPI/libraries/armem/server/query_proc/wm/wm.h>
#include <ArmarXCore/core/exceptions/LocalException.h>
diff --git a/source/RobotAPI/libraries/armem/test/CMakeLists.txt b/source/RobotAPI/libraries/armem/test/CMakeLists.txt
index 43b75650492c4d69a6fb08d5a550796e5dfd3a3b..a80618cee37da7a0ab0e3198d8f9eda431964bfb 100644
--- a/source/RobotAPI/libraries/armem/test/CMakeLists.txt
+++ b/source/RobotAPI/libraries/armem/test/CMakeLists.txt
@@ -6,6 +6,7 @@ armarx_add_test(ArMemForEachTest ArMemForEachTest.cpp "${LIBS}")
armarx_add_test(ArMemGetFindTest ArMemGetFindTest.cpp "${LIBS}")
armarx_add_test(ArMemIceConversionsTest ArMemIceConversionsTest.cpp "${LIBS}")
armarx_add_test(ArMemLTMTest ArMemLTMTest.cpp "${LIBS}")
+armarx_add_test(ArMemLTMBenchmark ArMemLTMBenchmark.cpp "${LIBS}")
armarx_add_test(ArMemMemoryTest ArMemMemoryTest.cpp "${LIBS}")
armarx_add_test(ArMemMemoryIDTest ArMemMemoryIDTest.cpp "${LIBS}")
armarx_add_test(ArMemQueryBuilderTest ArMemQueryBuilderTest.cpp "${LIBS}")
diff --git a/source/RobotAPI/libraries/armem/util/util.h b/source/RobotAPI/libraries/armem/util/util.h
index 3045d583a6a4144ed996a286257eb5ba2910b9c5..a517767921e51a0545e809fe74cc2230be478d26 100644
--- a/source/RobotAPI/libraries/armem/util/util.h
+++ b/source/RobotAPI/libraries/armem/util/util.h
@@ -27,7 +27,7 @@
#include <ArmarXCore/core/logging/Logging.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h>
namespace armarx::armem
@@ -43,7 +43,7 @@ namespace armarx::armem
template <typename AronClass>
std::optional<AronClass> tryCast(const wm::EntityInstance& item)
{
- static_assert(std::is_base_of<armarx::aron::cppserializer::AronCppClass,
+ static_assert(std::is_base_of<armarx::aron::codegenerator::cpp::AronCppClass,
AronClass>::value);
@@ -62,9 +62,7 @@ namespace armarx::armem
try
{
- AronClass t;
- t.fromAron(item.data());
- return t;
+ return AronClass::FromAron(item.data());
}
catch (const armarx::aron::error::AronException&)
{
@@ -83,7 +81,7 @@ namespace armarx::armem
std::vector<AronClass>
allOfType(const std::map<std::string, wm::Entity>& entities)
{
- static_assert(std::is_base_of<armarx::aron::cppserializer::AronCppClass,
+ static_assert(std::is_base_of<armarx::aron::codegenerator::cpp::AronCppClass,
AronClass>::value);
std::vector<AronClass> outV;
@@ -130,7 +128,7 @@ namespace armarx::armem
auto transformAllOfType(const std::map<std::string, wm::Entity>& entities,
auto pred) -> std::vector<decltype(pred(AronClass()))>
{
- static_assert(std::is_base_of<armarx::aron::cppserializer::AronCppClass,
+ static_assert(std::is_base_of<armarx::aron::codegenerator::cpp::AronCppClass,
AronClass>::value);
std::vector<decltype(pred(AronClass()))> outV;
diff --git a/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp b/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
index 6e2bbb30bd3d2258796da97ce8a81b24224d201e..3f4f2cf444028946646e433dae5d85a1b80144d0 100644
--- a/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
+++ b/source/RobotAPI/libraries/armem_gui/MemoryViewer.cpp
@@ -3,8 +3,8 @@
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
#include <RobotAPI/libraries/armem_gui/gui_utils.h>
-#include <RobotAPI/libraries/armem/server/query_proc/wm.h>
-#include <RobotAPI/libraries/armem/server/query_proc/ltm.h>
+#include <RobotAPI/libraries/armem/server/query_proc/wm/wm.h>
+#include <RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h>
#include <ArmarXGui/libraries/SimpleConfigDialog/SimpleConfigDialog.h>
@@ -140,6 +140,7 @@ namespace armarx::armem::gui
const bool update = true;
memoryReaders = mns.getAllReaders(update);
+ memoryWriters = mns.getAllWriters(update);
}
// DebugObserver is optional (check for null on every call)
if (not debugObserverName.empty())
@@ -185,7 +186,7 @@ namespace armarx::armem::gui
void MemoryViewer::storeInLTM()
{
- TIMING_START(MemoryStore)
+ TIMING_START(MemoryStore);
for (auto& [name, reader] : memoryReaders)
{
@@ -194,7 +195,7 @@ namespace armarx::armem::gui
reader.readAndStore(input);
}
- TIMING_END_STREAM(MemoryStore, ARMARX_VERBOSE)
+ TIMING_END_STREAM(MemoryStore, ARMARX_VERBOSE);
}
@@ -213,13 +214,17 @@ namespace armarx::armem::gui
void MemoryViewer::loadFromDisk(QString directory)
{
std::string status;
- std::map<std::string, wm::Memory> data =
- diskControl->loadFromDisk(directory, memoryGroup->queryWidget()->queryInput(), &status);
+ std::map<std::string, wm::Memory> data = diskControl->loadFromDisk(directory, memoryGroup->queryWidget()->queryInput(), &status);
for (auto& [name, memory] : data)
{
- this->memoryData[name] = std::move(memory);
+ if (memoryWriters.count(name) > 0)
+ {
+ auto commit = armem::toCommit(memory);
+ memoryWriters.at(name).commit(commit);
+ }
}
+
statusLabel->setText(QString::fromStdString(status));
emit memoryDataChanged();
@@ -228,7 +233,7 @@ namespace armarx::armem::gui
void MemoryViewer::startQueries()
{
- memoryReaders = mns.getAllReaders(true);
+ //memoryReaders = mns.getAllReaders(true);
startDueQueries(runningQueries, memoryReaders);
}
@@ -353,6 +358,7 @@ namespace armarx::armem::gui
// Drop all entries in memoryData which are not in memoryReaders anymore.
for (auto it = memoryData.begin(); it != memoryData.end();)
{
+ auto name = it->second.name();
if (memoryReaders.count(it->first) == 0)
{
it = memoryData.erase(it);
@@ -440,7 +446,7 @@ namespace armarx::armem::gui
handleError("Memory name is empty.");
}
- aron::typenavigator::ObjectNavigatorPtr segmentType;
+ aron::type::ObjectPtr segmentType;
std::optional<wm::EntityInstance> instance;
try
{
@@ -500,8 +506,6 @@ namespace armarx::armem::gui
convMap[name] = &data;
}
- // if convMap.empty(), we still need to update to remove existing entries.
-
TIMING_START(GuiUpdate)
memoryGroup->tree()->update(convMap);
TIMING_END_STREAM(GuiUpdate, ARMARX_VERBOSE)
diff --git a/source/RobotAPI/libraries/armem_gui/MemoryViewer.h b/source/RobotAPI/libraries/armem_gui/MemoryViewer.h
index e29a2352014cebaf1a700097f7409f7f32cb5229..3a1fb2a1c89d05f6c36c92e76514a6dcf2dd4cc4 100644
--- a/source/RobotAPI/libraries/armem_gui/MemoryViewer.h
+++ b/source/RobotAPI/libraries/armem_gui/MemoryViewer.h
@@ -10,6 +10,7 @@
#include <RobotAPI/interface/armem/mns/MemoryNameSystemInterface.h>
#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
#include <RobotAPI/libraries/armem/client/Reader.h>
+#include <RobotAPI/libraries/armem/client/Writer.h>
#include <RobotAPI/libraries/armem_gui/PeriodicUpdateWidget.h>
#include <RobotAPI/libraries/armem_gui/lifecycle.h>
#include <RobotAPI/libraries/armem_gui/instance/GroupBox.h>
@@ -135,6 +136,7 @@ namespace armarx::armem::gui
armem::client::MemoryNameSystem mns;
std::map<std::string, armem::client::Reader> memoryReaders;
+ std::map<std::string, armem::client::Writer> memoryWriters;
std::map<std::string, armem::wm::Memory> memoryData;
std::map<std::string, Ice::AsyncResultPtr> runningQueries;
diff --git a/source/RobotAPI/libraries/armem_gui/disk/ControlWidget.cpp b/source/RobotAPI/libraries/armem_gui/disk/ControlWidget.cpp
index 166256ba2e20bc72b560f481069b4fb9a927a825..4965ff7235ea012cbfff730777d5063bb910aa1a 100644
--- a/source/RobotAPI/libraries/armem_gui/disk/ControlWidget.cpp
+++ b/source/RobotAPI/libraries/armem_gui/disk/ControlWidget.cpp
@@ -1,8 +1,7 @@
#include "ControlWidget.h"
-#include <RobotAPI/libraries/armem/server/ltm/disk/MemoryManager.h>
-#include <RobotAPI/libraries/armem/server/ltm/disk/operations.h>
-#include <RobotAPI/libraries/armem/server/query_proc/ltm.h>
+#include <RobotAPI/libraries/armem/server/ltm/disk/Memory.h>
+#include <RobotAPI/libraries/armem/server/query_proc/ltm/disk/ltm.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
@@ -23,9 +22,9 @@ namespace armarx::armem::gui::disk
{
_latestDirectory = QString::fromStdString("/tmp/MemoryExport");
- _loadFromDiskButton = new QPushButton(" Load from Disk", this);
+ _loadFromDiskButton = new QPushButton(" Load Query from Disk into WM", this);
_loadFromDiskButton->setIcon(QIcon(":/icons/document-open.svg"));
- _storeOnDiskButton = new QPushButton(" Store on Disk", this);
+ _storeOnDiskButton = new QPushButton(" Store Query from WM on Disk", this);
_storeOnDiskButton->setIcon(QIcon(":/icons/document-save.svg"));
// Allow horizontal shrinking of buttons
@@ -103,11 +102,9 @@ namespace armarx::armem::gui::disk
{
std::filesystem::create_directories(path / name);
- armem::server::ltm::disk::MemoryManager manager;
- manager.setName(name);
- manager.setBasePath(path / name);
- manager.reload();
- manager.append(data);
+ armem::server::ltm::disk::Memory memory((path / name));
+ memory.store(data);
+ memory.storeBuffer();
numStored++;
}
@@ -149,9 +146,13 @@ namespace armarx::armem::gui::disk
{
if (dir.is_directory())
{
- std::string memoryName = dir.path().filename();
- armem::wm::Memory memory = armem::server::ltm::disk::load(dir.path());
- memoryData[memoryName] = std::move(memory);
+ armem::server::ltm::disk::Memory ltm(dir.path());
+
+ armem::wm::Memory memory;
+ ltm.loadAll(memory); // load list of references
+ ltm.load(memory); // resolve a list of references
+
+ memoryData[memory.name()] = std::move(memory);
numLoaded++;
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/ImageView.h b/source/RobotAPI/libraries/armem_gui/instance/ImageView.h
index 4b85e093a9ef522b7d125a6a0362a98dc4e11c52..ad3c6a0934e8cf7a9a09b17d1e2bd71b697008c3 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/ImageView.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/ImageView.h
@@ -63,7 +63,6 @@ namespace armarx::armem::gui::instance
QImage sourceImage;
QImage scaledImage;
-
};
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/InstanceView.cpp b/source/RobotAPI/libraries/armem_gui/instance/InstanceView.cpp
index da6ee43303128a3a73bf8db917301c41fe4b7695..b8704e934cbac1f17b8d1fe887f5c2707cae3bc2 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/InstanceView.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/InstanceView.cpp
@@ -20,8 +20,8 @@
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <RobotAPI/libraries/armem/aron/MemoryID.aron.generated.h>
#include <RobotAPI/libraries/armem/core/aron_conversions.h>
@@ -102,7 +102,7 @@ namespace armarx::armem::gui::instance
void InstanceView::update(const MemoryID& id, const wm::Memory& memory)
{
- aron::typenavigator::ObjectNavigatorPtr aronType = nullptr;
+ aron::type::ObjectPtr aronType = nullptr;
const armem::wm::EntityInstance* instance = nullptr;
try
{
@@ -123,7 +123,7 @@ namespace armarx::armem::gui::instance
}
- void InstanceView::update(const wm::EntityInstance& instance, aron::typenavigator::ObjectNavigatorPtr aronType)
+ void InstanceView::update(const wm::EntityInstance& instance, aron::type::ObjectPtr aronType)
{
currentInstance = instance;
currentAronType = aronType;
@@ -145,7 +145,7 @@ namespace armarx::armem::gui::instance
}
- void InstanceView::addInstanceView(const wm::EntityInstance& instance, aron::typenavigator::ObjectNavigatorPtr aronType)
+ void InstanceView::addInstanceView(const wm::EntityInstance& instance, aron::type::ObjectPtr aronType)
{
// ARMARX_IMPORTANT << "Adding instance view with toolbar for instance: " << instance.id();
InstanceView* view = new InstanceView;
@@ -172,7 +172,7 @@ namespace armarx::armem::gui::instance
void InstanceView::updateData(
- const aron::datanavigator::DictNavigatorPtr& data, aron::typenavigator::ObjectNavigatorPtr aronType)
+ const aron::data::DictPtr& data, aron::type::ObjectPtr aronType)
{
if (!data)
{
@@ -184,7 +184,7 @@ namespace armarx::armem::gui::instance
}
else if (useTypeInfo && aronType)
{
- treeItemData->setText(int(Columns::TYPE), QString::fromStdString(sanitizeTypeName(aronType->getName())));
+ treeItemData->setText(int(Columns::TYPE), QString::fromStdString(sanitizeTypeName(aronType->getFullName())));
TypedDataTreeBuilder builder;
builder.setColumns(int(Columns::KEY), int(Columns::VALUE), int(Columns::TYPE));
@@ -269,7 +269,6 @@ namespace armarx::armem::gui::instance
switch (type)
{
case aron::type::Descriptor::eImage:
- case aron::type::Descriptor::eIVTCByteImage:
{
if (const std::optional<aron::Path> path = getElementPath(item))
{
@@ -282,10 +281,10 @@ namespace armarx::armem::gui::instance
try
{
- aron::datanavigator::NavigatorPtr element = currentInstance->data()->navigateAbsolute(path.value());
- if (auto imageData = aron::datanavigator::NDArrayNavigator::DynamicCast(element))
+ aron::data::VariantPtr element = currentInstance->data()->navigateAbsolute(path.value());
+ if (auto imageData = aron::data::NDArray::DynamicCast(element))
{
- const std::vector<int> shape = imageData->getDimensions();
+ const std::vector<int> shape = imageData->getShape();
if (std::find(shape.begin(), shape.end(), 0) != shape.end())
{
viewAction->setText(viewAction->text() + " (image is empty)");
@@ -336,7 +335,7 @@ namespace armarx::armem::gui::instance
std::optional<MemoryID> InstanceView::getElementMemoryID(const aron::Path& elementPath)
{
- aron::datanavigator::NavigatorPtr element;
+ aron::data::VariantPtr element;
try
{
element = currentInstance->data()->navigateAbsolute(elementPath);
@@ -356,7 +355,7 @@ namespace armarx::armem::gui::instance
std::stringstream couldNotParseMsg;
couldNotParseMsg << "Element " << elementPath.toString() << " could not be parsed as MemoryID.";
- auto dictElement = std::dynamic_pointer_cast<aron::datanavigator::DictNavigator>(element);
+ auto dictElement = std::dynamic_pointer_cast<aron::data::Dict>(element);
if (!dictElement)
{
showErrorMessage(couldNotParseMsg.str() + " (Failed to cast to DictNavigator.)");
@@ -450,9 +449,9 @@ namespace armarx::armem::gui::instance
QImage InstanceView::ImageView::convertDepth32ToRGB32(
- const aron::datanavigator::NDArrayNavigator& aron)
+ const aron::data::NDArray& aron)
{
- const std::vector<int> shape = aron.getDimensions();
+ const std::vector<int> shape = aron.getShape();
ARMARX_CHECK_EQUAL(shape.size(), 3);
ARMARX_CHECK_EQUAL(shape.at(2), 4) << "Expected Depth32 image to have 4 bytes per pixel.";
@@ -539,9 +538,9 @@ namespace armarx::armem::gui::instance
}
- void InstanceView::updateImageView(const aron::datanavigator::DictNavigatorPtr& data)
+ void InstanceView::updateImageView(const aron::data::DictPtr& data)
{
- using aron::datanavigator::NDArrayNavigator;
+ using aron::data::NDArray;
if (not imageView)
{
@@ -553,7 +552,7 @@ namespace armarx::armem::gui::instance
return;
}
- aron::datanavigator::NavigatorPtr element;
+ aron::data::VariantPtr element;
try
{
element = data->navigateAbsolute(imageView->elementPath);
@@ -573,28 +572,29 @@ namespace armarx::armem::gui::instance
return;
}
- NDArrayNavigator::PointerType imageData = NDArrayNavigator::DynamicCast(element);
+ NDArray::PointerType imageData = NDArray::DynamicCast(element);
if (not imageData)
{
showErrorMessage("Expected NDArrayNavigator, but got: " + simox::meta::get_type_name(element));
return;
}
- const std::vector<int> shape = imageData->getDimensions();
+ const std::vector<int> shape = imageData->getShape();
if (shape.size() != 3)
{
showErrorMessage("Expected array shape with 3 dimensions, but got: "
- + NDArrayNavigator::DimensionsToString(shape));
+ + NDArray::DimensionsToString(shape));
return;
}
const int rows = shape.at(0);
const int cols = shape.at(1);
- using aron::typenavigator::ImagePixelType;
- std::optional<ImagePixelType> pixelType;
+ using aron::type::image::PixelType;
+ std::optional<PixelType> pixelType;
try
{
- pixelType = aron::typenavigator::ImageNavigator::pixelTypeFromName(imageData->getType());
+ // TODO We cannot know what the str in the pixeltype belongs to (e.g. coming from java, python, c++ it may contain different values!
+ //pixelType = aron::type::Image::pixelTypeFromName(imageData->getType());
}
catch (const aron::error::AronException&)
{
@@ -606,12 +606,12 @@ namespace armarx::armem::gui::instance
{
switch (pixelType.value())
{
- case ImagePixelType::Rgb24:
+ case PixelType::rgb24:
ARMARX_CHECK_EQUAL(shape.at(2), 3) << "Expected Rgb24 image to have 3 bytes per pixel.";
image = QImage(imageData->getData(), cols, rows, QImage::Format::Format_RGB888);
break;
- case ImagePixelType::Depth32:
+ case PixelType::depth32:
image = imageView->convertDepth32ToRGB32(*imageData);
clearLimitsHistory = false;
break;
@@ -632,7 +632,7 @@ namespace armarx::armem::gui::instance
default:
showErrorMessage("Expected 1 or 3 elements in last dimension, but got shape: "
- + NDArrayNavigator::DimensionsToString(shape));
+ + NDArray::DimensionsToString(shape));
return;
}
image = QImage(imageData->getData(), cols, rows, format);
diff --git a/source/RobotAPI/libraries/armem_gui/instance/InstanceView.h b/source/RobotAPI/libraries/armem_gui/instance/InstanceView.h
index ab434ba10c6084d4440f7ae2c08758f05f038ed4..314ed98954699e58f54a8be914ee3d14bc308ecf 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/InstanceView.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/InstanceView.h
@@ -10,7 +10,7 @@
#include <ArmarXCore/core/logging/Logging.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/type/variant/forward_declarations.h>
#include <RobotAPI/libraries/aron/core/Path.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
@@ -44,10 +44,10 @@ namespace armarx::armem::gui::instance
void setUseTypeInfo(bool enable);
void update(const MemoryID& id, const wm::Memory& memory);
- void update(const wm::EntityInstance& instance, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr);
+ void update(const wm::EntityInstance& instance, aron::type::ObjectPtr aronType = nullptr);
void update();
- void addInstanceView(const wm::EntityInstance& instance, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr);
+ void addInstanceView(const wm::EntityInstance& instance, aron::type::ObjectPtr aronType = nullptr);
signals:
@@ -68,9 +68,9 @@ namespace armarx::armem::gui::instance
private:
void updateInstanceID(const MemoryID& id);
- void updateData(const aron::datanavigator::DictNavigatorPtr& data, aron::typenavigator::ObjectNavigatorPtr aronType = nullptr);
+ void updateData(const aron::data::DictPtr& data, aron::type::ObjectPtr aronType = nullptr);
void updateMetaData(const wm::EntityInstanceMetadata& metadata);
- void updateImageView(const aron::datanavigator::DictNavigatorPtr& data);
+ void updateImageView(const aron::data::DictPtr& data);
void showErrorMessage(const std::string& message);
@@ -91,7 +91,7 @@ namespace armarx::armem::gui::instance
};
std::optional<wm::EntityInstance> currentInstance;
- aron::typenavigator::ObjectNavigatorPtr currentAronType = nullptr;
+ aron::type::ObjectPtr currentAronType = nullptr;
bool useTypeInfo = true;
QSplitter* splitter;
@@ -107,7 +107,7 @@ namespace armarx::armem::gui::instance
public:
ImageView();
- QImage convertDepth32ToRGB32(const aron::datanavigator::NDArrayNavigator& aron);
+ QImage convertDepth32ToRGB32(const aron::data::NDArray& aron);
instance::ImageView* view;
aron::Path elementPath;
diff --git a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.cpp b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.cpp
index af2192c2a36de2c89fcda1caa4f556cd5781315f..c5cfddb7c11c39f6953453a7f36e6ab7f5ad56f1 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.cpp
@@ -4,28 +4,29 @@
namespace armarx::aron
{
- std::string DataDisplayVisitor::getValue(DataNavigator& n)
+ std::string DataDisplayVisitor::getValue(const data::VariantPtr& n)
{
DataDisplayVisitor v;
- v.applyTo(n);
+ data::visit(v, n);
return v.value.str();
}
- bool DataDisplayVisitor::visitEnter(DictDataNavigator& n)
+ void DataDisplayVisitor::visitDict(const data::VariantPtr& n)
{
- value << n.childrenSize() << " items";
- return false;
+ auto x = data::Dict::DynamicCastAndCheck(n);
+ value << x->childrenSize() << " items";
}
- bool DataDisplayVisitor::visitEnter(ListDataNavigator& n)
+ void DataDisplayVisitor::visitList(const data::VariantPtr& n)
{
- value << n.childrenSize() << " items";
- return false;
+ auto x = data::List::DynamicCastAndCheck(n);
+ value << x->childrenSize() << " items";
}
- bool DataDisplayVisitor::visit(BoolDataNavigator& b)
+ void DataDisplayVisitor::visitBool(const data::VariantPtr& b)
{
- if (b.getValue())
+ auto x = data::Bool::DynamicCastAndCheck(b);
+ if (x->getValue())
{
value << "true";
}
@@ -33,44 +34,42 @@ namespace armarx::aron
{
value << "false";
}
- return false;
}
- bool DataDisplayVisitor::visit(DoubleDataNavigator& n)
+ void DataDisplayVisitor::visitDouble(const data::VariantPtr& n)
{
- value << n.getValue();
- return false;
+ auto x = data::Double::DynamicCastAndCheck(n);
+ value << x->getValue();
}
- bool DataDisplayVisitor::visit(FloatDataNavigator& n)
+ void DataDisplayVisitor::visitFloat(const data::VariantPtr& n)
{
- value << n.getValue();
- return false;
+ auto x = data::Float::DynamicCastAndCheck(n);
+ value << x->getValue();
}
- bool DataDisplayVisitor::visit(IntDataNavigator& n)
+ void DataDisplayVisitor::visitInt(const data::VariantPtr& n)
{
- value << n.getValue();
- return false;
+ auto x = data::Int::DynamicCastAndCheck(n);
+ value << x->getValue();
}
- bool DataDisplayVisitor::visit(LongDataNavigator& n)
+ void DataDisplayVisitor::visitLong(const data::VariantPtr& n)
{
- value << n.getValue();
- return false;
+ auto x = data::Long::DynamicCastAndCheck(n);
+ value << x->getValue();
}
- bool DataDisplayVisitor::visit(StringDataNavigator& n)
+ void DataDisplayVisitor::visitString(const data::VariantPtr& n)
{
- value << "'" << n.getValue() << "'";
- return false;
+ auto x = data::String::DynamicCastAndCheck(n);
+ value << "'" << x->getValue() << "'";
}
- bool DataDisplayVisitor::visit(NDArrayDataNavigator& n)
+ void DataDisplayVisitor::visitNDArray(const data::VariantPtr& n)
{
- value << "shape " << aron::datanavigator::NDArrayNavigator::DimensionsToString(n.getDimensions())
- << ", type '" << n.getType() << "'";
- return false;
+ auto x = data::NDArray::DynamicCastAndCheck(n);
+ value << "shape " << aron::data::NDArray::DimensionsToString(x->getShape()) << ", type '" << x->getType() << "'";
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.h b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.h
index 8f48a57f0cd42a7e69dec44dd37ec489b50b440d..1595e6ffb601278cb186d61f3a5f2535ff8bbcfb 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/DataDisplayVisitor.h
@@ -2,35 +2,33 @@
#include <sstream>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
namespace armarx::aron
{
- class DataDisplayVisitor : public aron::visitor::DataVisitor
+ class DataDisplayVisitor : public aron::data::ConstVariantVisitor
{
public:
-
- static std::string getValue(DataNavigator& n);
+ static std::string getValue(const data::VariantPtr& n);
public:
std::stringstream value;
+ void visitDict(const data::VariantPtr& n) override;
+ void visitList(const data::VariantPtr& n) override;
- bool visitEnter(DictDataNavigator& n) override;
- bool visitEnter(ListDataNavigator& n) override;
-
- bool visit(BoolDataNavigator& b) override;
- bool visit(DoubleDataNavigator& n) override;
- bool visit(FloatDataNavigator& n) override;
- bool visit(IntDataNavigator& n) override;
- bool visit(LongDataNavigator& n) override;
- bool visit(StringDataNavigator& n) override;
+ void visitBool(const data::VariantPtr& b) override;
+ void visitDouble(const data::VariantPtr& n) override;
+ void visitFloat(const data::VariantPtr& n) override;
+ void visitInt(const data::VariantPtr& n) override;
+ void visitLong(const data::VariantPtr& n) override;
+ void visitString(const data::VariantPtr& n) override;
- bool visit(NDArrayDataNavigator& n) override;
+ void visitNDArray(const data::VariantPtr& n) override;
};
diff --git a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.cpp b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.cpp
index 16c54007a40ad0f04d85c3bc4e9ecebcb4e74416..f426bf08da16341b679ead1f5883db038a029aab 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.cpp
@@ -17,11 +17,10 @@
namespace armarx::aron
{
- std::string TypedDataDisplayVisitor::getValue(TypeNavigator& type, DataNavigator& data)
+ std::string TypedDataDisplayVisitor::getValue(const type::VariantPtr& type, const data::VariantPtr& data)
{
TypedDataDisplayVisitor v;
- bool r = v.applyTo(type, data);
- ARMARX_CHECK(!r);
+ data::visit(v, data, type);
return v.value.str();
}
@@ -33,141 +32,134 @@ namespace armarx::aron
}
- bool TypedDataDisplayVisitor::visitEnter(DictTypeNavigator&, DictDataNavigator& data)
+ void TypedDataDisplayVisitor::visitDict(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visitEnter(ObjectTypeNavigator&, DictDataNavigator& data)
+ void TypedDataDisplayVisitor::visitObject(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visitEnter(ListTypeNavigator&, ListDataNavigator& data)
+ void TypedDataDisplayVisitor::visitList(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visitEnter(TupleTypeNavigator&, ListDataNavigator& data)
+ void TypedDataDisplayVisitor::visitTuple(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(BoolTypeNavigator&, BoolDataNavigator& data)
+ void TypedDataDisplayVisitor::visitBool(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(DoubleTypeNavigator&, DoubleDataNavigator& data)
+ void TypedDataDisplayVisitor::visitDouble(const data::VariantPtr& data, const type::VariantPtr& type)
{
setStreamPrecision();
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(FloatTypeNavigator&, FloatDataNavigator& data)
+ void TypedDataDisplayVisitor::visitFloat(const data::VariantPtr& data, const type::VariantPtr& type)
{
setStreamPrecision();
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(IntTypeNavigator&, IntDataNavigator& data)
+ void TypedDataDisplayVisitor::visitInt(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(LongTypeNavigator&, LongDataNavigator& data)
+ void TypedDataDisplayVisitor::visitLong(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(StringTypeNavigator&, StringDataNavigator& data)
+ void TypedDataDisplayVisitor::visitString(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(TimeTypeNavigator&, LongDataNavigator& data)
+ void TypedDataDisplayVisitor::visitTime(const data::VariantPtr& data, const type::VariantPtr& type)
{
- armem::Time time = armem::Time::microSeconds(data.getValue());
+ auto l = data::Long::DynamicCastAndCheck(data);
+ armem::Time time = armem::Time::microSeconds(l->getValue());
value << armem::toDateTimeMilliSeconds(time);
- return false;
}
template <typename ScalarT>
- void TypedDataDisplayVisitor::processEigenMatrix(EigenMatrixTypeNavigator& type, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::processMatrix(const type::Matrix& type, const data::NDArray& data)
{
Eigen::Map<Eigen::Matrix<ScalarT, Eigen::Dynamic, Eigen::Dynamic>> m(reinterpret_cast<ScalarT*>(data.getData()), type.getRows(), type.getCols());
value << m.format(eigenIof);
}
- bool TypedDataDisplayVisitor::visit(EigenMatrixTypeNavigator& t, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitMatrix(const data::VariantPtr& data, const type::VariantPtr& type)
{
+ auto t = *type::Matrix::DynamicCastAndCheck(type);
+ auto d = *data::NDArray::DynamicCastAndCheck(data);
+
if (std::max(t.getRows(), t.getCols()) > 10)
{
// Just show the shape.
value << DataDisplayVisitor::getValue(data);
}
- else if (data.getType() == "float")
+ else if (d.getType() == "float")
{
setStreamPrecision();
- processEigenMatrix<float>(t, data);
+ processMatrix<float>(t, d);
}
- else if (data.getType() == "double")
+ else if (d.getType() == "double")
{
setStreamPrecision();
- processEigenMatrix<double>(t, data);
+ processMatrix<double>(t, d);
}
else
{
value << DataDisplayVisitor::getValue(data);
}
- return false;
}
- bool TypedDataDisplayVisitor::visit(EigenQuaternionTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::processQuaternion(const data::NDArray& data)
{
- processEigenQuaternion(data);
- return false;
+ const Eigen::Quaternionf quat = aron::converter::AronEigenConverter::ConvertToQuaternionf(data);
+ setStreamPrecision();
+ value << quat.w() << coeffSep << "|" << coeffSep << quat.x() << coeffSep << quat.y() << coeffSep << quat.z();
}
- bool TypedDataDisplayVisitor::visit(ImageNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitQuaternion(const data::VariantPtr& data, const type::VariantPtr&)
{
- // aron::typenavigator::ImagePixelType pixelType = ImageNavigator::pixelTypeFromName(data.getType());
- //value << DataDisplayVisitor::getValue(data) << " pixel type: " << data.getType()";
- value << DataDisplayVisitor::getValue(data);
- return false;
+ auto d = *data::NDArray::DynamicCastAndCheck(data);
+ processQuaternion(d);
}
- bool TypedDataDisplayVisitor::visit(IVTCByteImageTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitOrientation(const data::VariantPtr& data, const type::VariantPtr&)
{
- value << DataDisplayVisitor::getValue(data);
- return false;
+ auto d = *data::NDArray::DynamicCastAndCheck(data);
+ processQuaternion(d);
}
- bool TypedDataDisplayVisitor::visit(OpenCVMatTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitImage(const data::VariantPtr& data, const type::VariantPtr& type)
{
+ // aron::typenavigator::ImagePixelType pixelType = ImageNavigator::pixelTypeFromName(data.getType());
+ //value << DataDisplayVisitor::getValue(data) << " pixel type: " << data.getType()";
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(PCLPointCloudTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitPointCloud(const data::VariantPtr& data, const type::VariantPtr& type)
{
value << DataDisplayVisitor::getValue(data);
- return false;
}
- bool TypedDataDisplayVisitor::visit(PoseTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitPose(const data::VariantPtr& data, const type::VariantPtr& type)
{
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+
const Eigen::IOFormat eigenIof(Eigen::StreamPrecision, 0, " ", "\n", "( ", " )", "", "");
const std::string cdot = "\u00B7"; // center dot: https://unicode-table.com/de/00B7/
@@ -181,7 +173,7 @@ namespace armarx::aron
return lines;
};
- const Eigen::Matrix4f pose = aron::converter::AronEigenConverter::ConvertToMatrix4f(data);
+ const Eigen::Matrix4f pose = aron::converter::AronEigenConverter::ConvertToMatrix4f(d);
const std::vector<std::string> r = getLines(simox::math::orientation(pose));
const std::vector<std::string> t = getLines(simox::math::position(pose));
@@ -191,29 +183,16 @@ namespace armarx::aron
lines.push_back(r.at(2) + " \t" + t.at(2));
value << simox::alg::join(lines, "\n");
- return false;
}
- bool TypedDataDisplayVisitor::visit(PositionTypeNavigator&, NDArrayDataNavigator& data)
+ void TypedDataDisplayVisitor::visitPosition(const data::VariantPtr& data, const type::VariantPtr& type)
{
- const Eigen::Vector3f pos = aron::converter::AronEigenConverter::ConvertToVector3f(data);
- setStreamPrecision();
- value << pos.format(eigenIof);
- return false;
- }
-
- bool TypedDataDisplayVisitor::visit(OrientationTypeNavigator&, NDArrayDataNavigator& data)
- {
- processEigenQuaternion(data);
- return false;
- }
+ auto d = data::NDArray::DynamicCastAndCheck(data);
- void TypedDataDisplayVisitor::processEigenQuaternion(visitor::TypedDataVisitor::NDArrayDataNavigator& data)
- {
- const Eigen::Quaternionf quat = aron::converter::AronEigenConverter::ConvertToQuaternionf(data);
+ const Eigen::Vector3f pos = aron::converter::AronEigenConverter::ConvertToVector3f(d);
setStreamPrecision();
- value << quat.w() << coeffSep << "|" << coeffSep << quat.x() << coeffSep << quat.y() << coeffSep << quat.z();
+ value << pos.format(eigenIof);
}
void TypedDataDisplayVisitor::setStreamPrecision()
diff --git a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.h b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.h
index 4bf2ec5d8cd149eb40ad1f9a0d3a655424183e72..fa42d27adc750a48cdd7bdadafa9bc41ee4e5945 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/display_visitors/TypedDataDisplayVisitor.h
@@ -5,17 +5,17 @@
#include <Eigen/Core>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
namespace armarx::aron
{
- class TypedDataDisplayVisitor : public aron::visitor::TypedDataVisitor
+ class TypedDataDisplayVisitor : public aron::data::ConstTypedVariantVisitor
{
public:
- static std::string getValue(TypeNavigator& type, DataNavigator& data);
+ static std::string getValue(const type::VariantPtr& type, const data::VariantPtr& data);
public:
@@ -26,31 +26,30 @@ namespace armarx::aron
std::stringstream value;
- bool visitEnter(DictTypeNavigator&, DictDataNavigator& data) override;
- bool visitEnter(ObjectTypeNavigator&, DictDataNavigator& data) override;
+ void visitDict(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitObject(const data::VariantPtr& data, const type::VariantPtr& type) override;
- bool visitEnter(ListTypeNavigator&, ListDataNavigator& data) override;
- bool visitEnter(TupleTypeNavigator&, ListDataNavigator& data) override;
+ void visitList(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitTuple(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ // What about Pair? currently defaulted
+ void visitBool(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitDouble(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitFloat(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitInt(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitLong(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitString(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitTime(const data::VariantPtr& data, const type::VariantPtr& type) override;
- bool visit(BoolTypeNavigator&, BoolDataNavigator& data) override;
- bool visit(DoubleTypeNavigator&, DoubleDataNavigator& data) override;
- bool visit(FloatTypeNavigator&, FloatDataNavigator& data) override;
- bool visit(IntTypeNavigator&, IntDataNavigator& data) override;
- bool visit(LongTypeNavigator&, LongDataNavigator& data) override;
- bool visit(StringTypeNavigator&, StringDataNavigator& data) override;
- bool visit(TimeTypeNavigator&, LongDataNavigator& data) override;
-
- bool visit(EigenMatrixTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(EigenQuaternionTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(ImageNavigator&, NDArrayDataNavigator& data) override;
- bool visit(IVTCByteImageTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(OpenCVMatTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(PCLPointCloudTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(PoseTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(PositionTypeNavigator&, NDArrayDataNavigator& data) override;
- bool visit(OrientationTypeNavigator&, NDArrayDataNavigator& data) override;
+ void visitMatrix(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitQuaternion(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitImage(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitPointCloud(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitPose(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitPosition(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ void visitOrientation(const data::VariantPtr& data, const type::VariantPtr& type) override;
+ // What about NDArray? currently defaulted
protected:
@@ -62,8 +61,8 @@ namespace armarx::aron
private:
template <typename ScalarT>
- void processEigenMatrix(EigenMatrixTypeNavigator&, NDArrayDataNavigator& data);
- void processEigenQuaternion(NDArrayDataNavigator& data);
+ void processMatrix(const type::Matrix&, const data::NDArray& data);
+ void processQuaternion(const data::NDArray& data);
void setStreamPrecision();
void setStreamPrecision(std::ostream& os);
diff --git a/source/RobotAPI/libraries/armem_gui/instance/sanitize_typename.cpp b/source/RobotAPI/libraries/armem_gui/instance/sanitize_typename.cpp
index e8ece36b766dec34b3bce7325b7a62e78513bbc2..bc4b1878fba11a5e9621735b9bee19e72548b05c 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/sanitize_typename.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/sanitize_typename.cpp
@@ -7,7 +7,7 @@
#include <RobotAPI/libraries/armem/aron/MemoryID.aron.generated.h>
-const std::string armarx::armem::gui::instance::rawMemoryIDTypeName = armarx::armem::arondto::MemoryID::toAronType()->getName();
+const std::string armarx::armem::gui::instance::rawMemoryIDTypeName = armarx::armem::arondto::MemoryID::toAronType()->getFullName();
const std::string armarx::armem::gui::instance::sanitizedMemoryIDTypeName = "MemoryID";
@@ -35,29 +35,13 @@ std::string armarx::armem::gui::instance::sanitizeTypeName(const std::string& ty
namespace s = simox::alg;
std::string n = typeName;
- n = s::replace_all(n, "type::Aron", "");
- n = s::replace_all(n, "data::Aron", "");
+ n = s::replace_all(n, "armarx::aron::type::", "");
+ n = s::replace_all(n, "armarx::aron::data::", "");
- if (false)
+ if (s::starts_with(n, "Object<"))
{
- const std::vector<std::string> containers { "Dict", "List", "Object", "Tuple", "Pair", "NDArray" };
- for (const std::string& s : containers)
- {
- n = s::replace_all(n, s + "Type", s);
- }
- }
- else
- {
- n = s::replace_all(n, "Type", "");
- }
-
-
- n = simox::alg::remove_prefix(n, "Aron");
- n = remove_wrap(n, "Object<", ">");
-
- if (true)
- {
- const std::string del = "::";
+ n = remove_wrap(n, "Object<", ">");
+ const std::string del = "::"; // remove namespace
size_t find = n.rfind(del);
if (find != n.npos)
{
@@ -67,6 +51,16 @@ std::string armarx::armem::gui::instance::sanitizeTypeName(const std::string& ty
n = ss.str();
}
}
+ else
+ {
+ if (s::contains(n, "<")) // another containertype
+ {
+ std::string container = n.substr(0, n.find("<"));
+ std::string subtype = remove_wrap(n, (container + "<"), ">");
+ subtype = sanitizeTypeName(subtype);
+ n = n.substr(0, n.find("<")+1) + subtype + ">";
+ }
+ }
return n;
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.cpp b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.cpp
index bdf6aed5bb00495bf74d0125a60b4e108e8bcd64..5ed578979d2516f3c089685c1bf5bc44843ad157 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.cpp
@@ -12,7 +12,7 @@ namespace armarx::armem::gui::instance
{
}
- void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, const aron::datanavigator::DictNavigatorPtr& data)
+ void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, const aron::data::DictPtr& data)
{
DictBuilder builder = getDictBuilder();
builder.setUpdateItemFn([this, &data](const std::string & key, QTreeWidgetItem * item)
@@ -25,7 +25,7 @@ namespace armarx::armem::gui::instance
builder.updateTreeWithContainer(parent, data->getAllKeys());
}
- void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, const aron::datanavigator::ListNavigatorPtr& data)
+ void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, const aron::data::ListPtr& data)
{
auto children = data->getChildren();
@@ -40,17 +40,17 @@ namespace armarx::armem::gui::instance
}
- void DataTreeBuilder::update(QTreeWidgetItem* item, const std::string& key, const aron::datanavigator::NavigatorPtr& data)
+ void DataTreeBuilder::update(QTreeWidgetItem* item, const std::string& key, const aron::data::VariantPtr& data)
{
if (data)
{
- this->setRowTexts(item, key, *data);
+ this->setRowTexts(item, key, data);
- if (auto cast = aron::datanavigator::DictNavigator::DynamicCast(data))
+ if (auto cast = aron::data::Dict::DynamicCast(data))
{
updateTree(item, cast);
}
- else if (auto cast = aron::datanavigator::ListNavigator::DynamicCast(data))
+ else if (auto cast = aron::data::List::DynamicCast(data))
{
updateTree(item, cast);
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.h b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.h
index cd408a34c3d3ebe2d36e5efe4cc7435ebefb0d94..4ae61c3036195e08055582d5e7251857a30ca650 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilder.h
@@ -2,8 +2,8 @@
#include <string>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/List.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/List.h>
#include "DataTreeBuilderBase.h"
@@ -17,13 +17,13 @@ namespace armarx::armem::gui::instance
DataTreeBuilder();
- void updateTree(QTreeWidgetItem* parent, const aron::datanavigator::DictNavigatorPtr& data);
- void updateTree(QTreeWidgetItem* parent, const aron::datanavigator::ListNavigatorPtr& data);
+ void updateTree(QTreeWidgetItem* parent, const aron::data::DictPtr& data);
+ void updateTree(QTreeWidgetItem* parent, const aron::data::ListPtr& data);
protected:
- void update(QTreeWidgetItem* item, const std::string& key, const aron::datanavigator::NavigatorPtr& data);
+ void update(QTreeWidgetItem* item, const std::string& key, const aron::data::VariantPtr& data);
};
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.cpp b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.cpp
index 8a73afd2069896bbea2577b8f6d73f7df95b1ab5..1f0d140918dc615251e67629df69e3c2b5d53ff0 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.cpp
@@ -52,10 +52,14 @@ namespace armarx::armem::gui::instance
void DataTreeBuilderBase::setRowTexts(
- QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data)
+ QTreeWidgetItem* item, const std::string& key, const aron::data::VariantPtr& data)
{
+ if (!data)
+ {
+ return;
+ }
const std::string value = armarx::aron::DataDisplayVisitor::getValue(data);
- setRowTexts(item, key, value, sanitizeTypeName(data.getName()));
+ setRowTexts(item, key, value, sanitizeTypeName(data->getFullName()));
}
DataTreeBuilderBase::DictBuilder DataTreeBuilderBase::getDictBuilder() const
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.h b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.h
index d8ce4516b43c7cbccfaff7bfbd5f362d6dbfef0a..2988b5e9cf55965381eb1e4642728a201cd52e7d 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/DataTreeBuilderBase.h
@@ -2,7 +2,7 @@
#include <string>
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
namespace armarx
@@ -40,7 +40,7 @@ namespace armarx::armem::gui::instance
QTreeWidgetItem* makeItem(size_t key) const;
void setRowTexts(QTreeWidgetItem* item, const std::string& key, const std::string& value, const std::string& typeName = "") const;
- void setRowTexts(QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data);
+ void setRowTexts(QTreeWidgetItem* item, const std::string& key, const aron::data::VariantPtr& data);
public:
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.cpp b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.cpp
index bda945607d2dc2e11b40957941b370613825aad3..eae4cb934e7c878c2c2f7787f0ef0cd96a2f9775 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.cpp
@@ -24,8 +24,8 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::updateTree(
QTreeWidgetItem* parent,
- aron::typenavigator::DictNavigator& type,
- aron::datanavigator::DictNavigator& data)
+ const aron::type::Dict& type,
+ const aron::data::Dict& data)
{
auto childType = type.getAcceptedType();
if (childType)
@@ -36,7 +36,7 @@ namespace armarx::armem::gui::instance
auto childData = data.getElement(key);
if (childData)
{
- this->update(item, key, *childType, childData.get());
+ this->update(item, key, childType, childData);
}
return true;
});
@@ -48,13 +48,13 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::updateTree(
QTreeWidgetItem* parent,
- aron::typenavigator::ObjectNavigator& type,
- aron::datanavigator::DictNavigator& data)
+ const aron::type::Object& type,
+ const aron::data::Dict& data)
{
DictBuilder builder = getDictBuilder();
builder.setMakeItemFn([this, &type](const std::string & key) -> QTreeWidgetItem*
{
- if (type.getMemberType(key)->getName() == instance::rawMemoryIDTypeName)
+ if (type.getMemberType(key)->getFullName() == instance::rawMemoryIDTypeName)
{
MemoryIDTreeWidgetItem* item = new MemoryIDTreeWidgetItem({QString::fromStdString(key)});
item->addKeyChildren();
@@ -72,7 +72,7 @@ namespace armarx::armem::gui::instance
if (childType)
{
- this->update(item, key, *childType, childData.get());
+ this->update(item, key, childType, childData);
}
return true;
});
@@ -82,8 +82,8 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::ListNavigator& type,
- aron::datanavigator::ListNavigator& data)
+ const aron::type::List& type,
+ const aron::data::List& data)
{
auto childType = type.getAcceptedType();
if (childType)
@@ -95,7 +95,7 @@ namespace armarx::armem::gui::instance
{
if (auto childData = children.at(key))
{
- this->update(item, std::to_string(key), *childType, childData.get());
+ this->update(item, std::to_string(key), childType, childData);
}
return true;
});
@@ -107,8 +107,8 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::updateTree(
QTreeWidgetItem* parent,
- aron::typenavigator::PairNavigator& type,
- aron::datanavigator::ListNavigator& data)
+ const aron::type::Pair& type,
+ const aron::data::List& data)
{
ARMARX_CHECK_EQUAL(data.childrenSize(), 2);
auto childTypes = type.getAcceptedTypes();
@@ -121,7 +121,7 @@ namespace armarx::armem::gui::instance
if (childType)
{
- this->update(item, std::to_string(i), *childType, childData.get());
+ this->update(item, std::to_string(i), childType, childData);
}
return true;
});
@@ -132,8 +132,8 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::updateTree(
QTreeWidgetItem* parent,
- aron::typenavigator::TupleNavigator& type,
- aron::datanavigator::ListNavigator& data)
+ const aron::type::Tuple& type,
+ const aron::data::List& data)
{
auto childTypes = type.getAcceptedTypes();
@@ -145,7 +145,7 @@ namespace armarx::armem::gui::instance
if (childType)
{
- this->update(item, std::to_string(i), *childType, childData.get());
+ this->update(item, std::to_string(i), childType, childData);
}
return true;
});
@@ -157,14 +157,14 @@ namespace armarx::armem::gui::instance
void TypedDataTreeBuilder::update(
QTreeWidgetItem* item,
const std::string& key,
- aron::typenavigator::Navigator& type,
- aron::datanavigator::Navigator* data)
+ const aron::type::VariantPtr& type,
+ const aron::data::VariantPtr& data)
{
using namespace aron;
- const std::string value = data ? aron::TypedDataDisplayVisitor::getValue(type, *data) : "(none)";
- std::string typeName = instance::sanitizeTypeName(type.getName());
- switch (type.getMaybe())
+ const std::string value = data ? aron::TypedDataDisplayVisitor::getValue(type, data) : "(none)";
+ std::string typeName = instance::sanitizeTypeName(type->getFullName());
+ switch (type->getMaybe())
{
case aron::type::Maybe::eOptional:
typeName = "Optional[" + typeName + "]";
@@ -176,17 +176,17 @@ namespace armarx::armem::gui::instance
setRowTexts(item, key, value, typeName);
item->setData(columnKey, Qt::UserRole, data ? instance::serializePath(data->getPath()) : QStringList());
- item->setData(columnType, Qt::UserRole, static_cast<int>(type.getDescriptor()));
+ item->setData(columnType, Qt::UserRole, static_cast<int>(type->getDescriptor()));
if (typeName == sanitizedMemoryIDTypeName)
{
MemoryIDTreeWidgetItem* memoryIDItem = dynamic_cast<MemoryIDTreeWidgetItem*>(item);
- datanavigator::DictNavigator* dictData = dynamic_cast<datanavigator::DictNavigator*>(data);
+ const auto dictData = aron::data::Dict::DynamicCastAndCheck(data);
if (memoryIDItem && dictData)
{
arondto::MemoryID dto;
// Because fromAron does not take refs -.-
- dto.fromAron(std::make_shared<datanavigator::DictNavigator>(*dictData));
+ dto.fromAron(dictData);
MemoryID id = aron::fromAron<MemoryID>(dto);
memoryIDItem->setInstanceID(id);
@@ -196,35 +196,35 @@ namespace armarx::armem::gui::instance
if (data)
{
- if (auto t = dynamic_cast<typenavigator::ObjectNavigator*>(&type))
+ if (const auto d = aron::data::Dict::DynamicCast(data); const auto t = type::Object::DynamicCast(type))
{
- _updateTree<datanavigator::DictNavigator>(item, *t, *data);
+ _updateTree(item, *t, *d);
}
- else if (auto t = dynamic_cast<typenavigator::DictNavigator*>(&type))
+ else if (const auto d = aron::data::Dict::DynamicCast(data); const auto t = type::Dict::DynamicCast(type))
{
- _updateTree<datanavigator::DictNavigator>(item, *t, *data);
+ _updateTree(item, *t, *d);
}
- else if (auto t = dynamic_cast<typenavigator::ListNavigator*>(&type))
+ else if (const auto d = aron::data::List::DynamicCast(data); const auto t = type::List::DynamicCast(type))
{
- _updateTree<datanavigator::ListNavigator>(item, *t, *data);
+ _updateTree(item, *t, *d);
}
- else if (auto t = dynamic_cast<typenavigator::PairNavigator*>(&type))
+ else if (const auto d = aron::data::List::DynamicCast(data); const auto t = type::Pair::DynamicCast(type))
{
- _updateTree<datanavigator::ListNavigator>(item, *t, *data);
+ _updateTree(item, *t, *d);
}
- else if (auto t = dynamic_cast<typenavigator::TupleNavigator*>(&type))
+ else if (const auto d = aron::data::List::DynamicCast(data); const auto t = type::Tuple::DynamicCast(type))
{
- _updateTree<datanavigator::ListNavigator>(item, *t, *data);
+ _updateTree(item, *t, *d);
}
+ // else???
}
}
template <class DataT, class TypeT>
- void TypedDataTreeBuilder::_updateTree(QTreeWidgetItem* item, TypeT& type, aron::datanavigator::Navigator& data)
+ void TypedDataTreeBuilder::_updateTree(QTreeWidgetItem* item, TypeT& type, DataT& data)
{
- DataT& dataCast = dynamic_cast<DataT&>(data);
- updateTree(item, type, dataCast);
+ updateTree(item, type, data);
}
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.h b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.h
index 0dead6736a93073854f8593d423ba03e60e8e0cb..b4e6dc91bc963ac799e5230f95f5e46c7fb79ebb 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_builders/TypedDataTreeBuilder.h
@@ -2,16 +2,16 @@
#include <string>
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/List.h>
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/List.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/List.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Pair.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/List.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Pair.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Tuple.h>
#include "DataTreeBuilderBase.h"
@@ -30,32 +30,32 @@ namespace armarx::armem::gui::instance
void updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::DictNavigator& type,
- aron::datanavigator::DictNavigator& data);
+ const aron::type::Dict& type,
+ const aron::data::Dict& data);
void updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::ObjectNavigator& type,
- aron::datanavigator::DictNavigator& data);
+ const aron::type::Object& type,
+ const aron::data::Dict& data);
void updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::ListNavigator& type,
- aron::datanavigator::ListNavigator& data);
+ const aron::type::List& type,
+ const aron::data::List& data);
void updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::PairNavigator& type,
- aron::datanavigator::ListNavigator& data);
+ const aron::type::Pair& type,
+ const aron::data::List& data);
void updateTree(QTreeWidgetItem* parent,
- aron::typenavigator::TupleNavigator& type,
- aron::datanavigator::ListNavigator& data);
+ const aron::type::Tuple& type,
+ const aron::data::List& data);
protected:
void update(QTreeWidgetItem* item,
const std::string& key,
- aron::typenavigator::Navigator& type,
- aron::datanavigator::Navigator* data);
+ const aron::type::VariantPtr& type,
+ const aron::data::VariantPtr& data);
template <class DataT, class TypeT>
- void _updateTree(QTreeWidgetItem* item, TypeT& type, aron::datanavigator::Navigator& data);
+ void _updateTree(QTreeWidgetItem* item, TypeT& type, DataT& data);
};
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitor.h b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitor.h
index 61d76bcfc58a81d138a442d07e1f64bc0eb7b922..0bab97220aeecf9897ac0f4a8dde786c97315fed 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitor.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitor.h
@@ -6,8 +6,6 @@
#include <QTreeWidget>
#include <QLabel>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
-
#include <RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h>
@@ -15,7 +13,7 @@ namespace armarx::armem::gui::instance
{
class TreeDataVisitor :
- public aron::visitor::DataVisitor,
+ public aron::data::RecursiveConstVariantVisitor,
public TreeDataVisitorBase
{
public:
@@ -23,53 +21,69 @@ namespace armarx::armem::gui::instance
using TreeDataVisitorBase::TreeDataVisitorBase;
- bool visitEnter(const std::string& key, DictDataNavigator& n) override
+ void visitDictOnEnter(const aron::data::VariantPtr& n) override
{
- return _visitEnter(key, "Dict", n.childrenSize());
+ const std::string key = n->getPath().getLastElement();
+ _visitEnter(key, "Dict", n->childrenSize());
}
- bool visitExit(DictDataNavigator&) override
+ void visitDictOnExit(const aron::data::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
- bool visitEnter(const std::string& key, ListDataNavigator& n) override
+ void visitListOnEnter(const aron::data::VariantPtr& n) override
{
- return _visitEnter(key, "List", n.childrenSize());
+ const std::string key = n->getPath().getLastElement();
+ _visitEnter(key, "List", n->childrenSize());
}
- bool visitExit(ListDataNavigator&) override
+ void visitListOnExit(const aron::data::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
- bool visit(const std::string& key, BoolDataNavigator& b) override
+ void visitBool(const aron::data::VariantPtr& b) override
{
- return this->addValueRow(key, b, "Bool");
+ const auto x = *aron::data::Bool::DynamicCastAndCheck(b);
+ const std::string key = b->getPath().getLastElement();
+ this->addValueRow(key, x, "Bool");
}
- bool visit(const std::string& key, DoubleDataNavigator& d) override
+ void visitDouble(const aron::data::VariantPtr& d) override
{
- return this->addValueRow(key, d, "Double");
+ const auto x = *aron::data::Double::DynamicCastAndCheck(d);
+ const std::string key = d->getPath().getLastElement();
+ this->addValueRow(key, x, "Double");
}
- bool visit(const std::string& key, FloatDataNavigator& f) override
+ void visitFloat(const aron::data::VariantPtr& f) override
{
- return this->addValueRow(key, f, "Float");
+ const auto x = *aron::data::Float::DynamicCastAndCheck(f);
+ const std::string key = f->getPath().getLastElement();
+ this->addValueRow(key, x, "Float");
}
- bool visit(const std::string& key, IntDataNavigator& i) override
+ void visitInt(const aron::data::VariantPtr& i) override
{
- return this->addValueRow(key, i, "Int");
+ const auto x = *aron::data::Int::DynamicCastAndCheck(i);
+ const std::string key = i->getPath().getLastElement();
+ this->addValueRow(key, x, "Int");
}
- bool visit(const std::string& key, LongDataNavigator& l) override
+ void visitLong(const aron::data::VariantPtr& l) override
{
- return this->addValueRow(key, l, "Long");
+ const auto x = *aron::data::Long::DynamicCastAndCheck(l);
+ const std::string key = l->getPath().getLastElement();
+ this->addValueRow(key, x, "Long");
}
- bool visit(const std::string& key, StringDataNavigator& string) override
+ void visitString(const aron::data::VariantPtr& string) override
{
- return this->addValueRow(key, string, "String");
+ const auto x = *aron::data::String::DynamicCastAndCheck(string);
+ const std::string key = string->getPath().getLastElement();
+ this->addValueRow(key, x, "String");
}
- bool visit(const std::string& key, NDArrayDataNavigator& array) override
+ void visitNDArray(const aron::data::VariantPtr& array) override
{
- return this->addValueRow(key, array, "ND Array");
+ const auto x = *aron::data::NDArray::DynamicCastAndCheck(array);
+ const std::string key = array->getPath().getLastElement();
+ this->addValueRow(key, x, "ND Array");
}
};
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.cpp b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.cpp
index 87cd2ffb9bdee5de102b3b026fb508784f0ff0c0..ea8973efc4c48a510f66698ca3ca53dfaf4dd926 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.cpp
@@ -62,7 +62,7 @@ namespace armarx::armem::gui::instance
return true;
}
- void TreeDataVisitorBase::streamValueText(aron::visitor::DataVisitor::BoolDataNavigator& n, std::stringstream& ss) const
+ void TreeDataVisitorBase::streamValueText(const aron::data::Bool& n, std::stringstream& ss) const
{
if (n.getValue())
{
@@ -74,14 +74,14 @@ namespace armarx::armem::gui::instance
}
}
- void TreeDataVisitorBase::streamValueText(aron::visitor::DataVisitor::StringDataNavigator& n, std::stringstream& ss) const
+ void TreeDataVisitorBase::streamValueText(const aron::data::String& n, std::stringstream& ss) const
{
ss << "'" << n.getValue() << "'";
}
- void TreeDataVisitorBase::streamValueText(aron::visitor::DataVisitor::NDArrayDataNavigator& n, std::stringstream& ss) const
+ void TreeDataVisitorBase::streamValueText(const aron::data::NDArray& n, std::stringstream& ss) const
{
- ss << "shape " << aron::datanavigator::NDArrayNavigator::DimensionsToString(n.getDimensions());
+ ss << "shape " << aron::data::NDArray::DimensionsToString(n.getShape());
}
}
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h
index c9d4ab0cdaf462761b10e422ef41f415ec54d7a1..7250ce376380ec0967989d369a0031ecf210e537 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h
@@ -6,7 +6,7 @@
#include <QTreeWidget>
#include <QLabel>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
namespace armarx::armem::gui::instance
@@ -62,9 +62,9 @@ namespace armarx::armem::gui::instance
{
ss << n.getValue();
}
- void streamValueText(aron::visitor::DataVisitor::BoolDataNavigator& n, std::stringstream& ss) const;
- void streamValueText(aron::visitor::DataVisitor::StringDataNavigator& n, std::stringstream& ss) const;
- void streamValueText(aron::visitor::DataVisitor::NDArrayDataNavigator& n, std::stringstream& ss) const;
+ void streamValueText(const aron::data::Bool& n, std::stringstream& ss) const;
+ void streamValueText(const aron::data::String& n, std::stringstream& ss) const;
+ void streamValueText(const aron::data::NDArray& n, std::stringstream& ss) const;
public:
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.cpp b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.cpp
index c4ed919f9b46be2c62966fccbd89fbefa0370449..3a3a3b4d6f007a92a009df9d59ddd5ad65d9c070 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.cpp
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.cpp
@@ -14,14 +14,14 @@
namespace armarx::armem::gui::instance
{
- QTreeWidgetItem* TreeTypedDataVisitor::makeItem(const std::string& key, NDArrayDataNavigator& data, const PoseTypeNavigator& type) const
+ QTreeWidgetItem* TreeTypedDataVisitor::makeItem(const std::string& key, aron::data::NDArray& data, const aron::type::Pose& type) const
{
- QTreeWidgetItem* item = makeItem<NDArrayDataNavigator, PoseTypeNavigator>(key, data, type);
+ QTreeWidgetItem* item = makeItem<aron::data::NDArray, aron::type::Pose>(key, data, type);
// ToDo: Do something special.
return item;
}
- void TreeTypedDataVisitor::streamValueText(LongDataNavigator& data, const TimeTypeNavigator& type, std::stringstream& ss) const
+ void TreeTypedDataVisitor::streamValueText(const aron::data::Long& data, const aron::type::Time& type, std::stringstream& ss) const
{
(void) type;
armem::Time time = armem::Time::microSeconds(data.getValue());
@@ -29,7 +29,7 @@ namespace armarx::armem::gui::instance
ss << armem::toDateTimeMilliSeconds(time);
}
- void TreeTypedDataVisitor::streamValueText(NDArrayDataNavigator& data, const PoseTypeNavigator& type, std::stringstream& ss) const
+ void TreeTypedDataVisitor::streamValueText(const aron::data::NDArray& data, const aron::type::Pose& type, std::stringstream& ss) const
{
(void) type;
const Eigen::Matrix4f pose = aron::converter::AronEigenConverter::ConvertToMatrix4f(data);
@@ -37,7 +37,7 @@ namespace armarx::armem::gui::instance
ss << pose.format(Eigen::IOFormat(Eigen::StreamPrecision, 0, coeffSep, "\n", "", "", "", ""));
}
- void TreeTypedDataVisitor::streamValueText(NDArrayDataNavigator& data, const PositionTypeNavigator& type, std::stringstream& ss) const
+ void TreeTypedDataVisitor::streamValueText(const aron::data::NDArray& data, const aron::type::Position& type, std::stringstream& ss) const
{
(void) type;
const Eigen::Vector3f pos = aron::converter::AronEigenConverter::ConvertToVector3f(data);
@@ -45,7 +45,7 @@ namespace armarx::armem::gui::instance
ss << pos.format(Eigen::IOFormat(Eigen::StreamPrecision, 0, "", coeffSep, "", "", "", ""));
}
- void TreeTypedDataVisitor::streamValueText(NDArrayDataNavigator& data, const OrientationTypeNavigator& type, std::stringstream& ss) const
+ void TreeTypedDataVisitor::streamValueText(const aron::data::NDArray& data, const aron::type::Orientation& type, std::stringstream& ss) const
{
(void) type;
const Eigen::Quaternionf quat = aron::converter::AronEigenConverter::ConvertToQuaternionf(data);
diff --git a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.h b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.h
index 49885f7eb3d66e561e0a83c496524907afd5d049..558057cc067b5c4c5525ebe3ec3701350da68729 100644
--- a/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.h
+++ b/source/RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeTypedDataVisitor.h
@@ -6,7 +6,7 @@
#include <QTreeWidget>
#include <QLabel>
-#include <RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
#include <RobotAPI/libraries/armem_gui/instance/sanitize_typename.h>
#include <RobotAPI/libraries/armem_gui/instance/serialize_path.h>
@@ -20,7 +20,7 @@ namespace armarx::armem::gui::instance
{
class TreeTypedDataVisitor :
- public aron::visitor::TypedDataVisitor,
+ public aron::data::RecursiveConstTypedVariantVisitor,
public TreeDataVisitorBase
{
public:
@@ -28,111 +28,205 @@ namespace armarx::armem::gui::instance
using TreeDataVisitorBase::TreeDataVisitorBase;
- bool visitEnter(DictTypeNavigator& type, const std::string& key, DictDataNavigator& data) override
+ void visitDictOnEnter(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return _visitEnter(key, sanitizeTypeName(type.getName()), data.childrenSize());
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+ _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
}
- bool visitExit(DictTypeNavigator&, DictDataNavigator&) override
+ void visitDictOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
- bool visitEnter(ObjectTypeNavigator& type, const std::string& key, DictDataNavigator& data) override
+ void visitObjectOnEnter(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return _visitEnter(key, sanitizeTypeName(type.getName()), data.childrenSize());
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+ _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
}
- bool visitExit(ObjectTypeNavigator&, DictDataNavigator&) override
+ void visitObjectOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
- bool visitEnter(ListTypeNavigator& type, const std::string& key, ListDataNavigator& data) override
+ void visitListOnEnter(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return _visitEnter(key, sanitizeTypeName(type.getName()), data.childrenSize());
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+ _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
}
- bool visitExit(ListTypeNavigator&, ListDataNavigator&) override
+ void visitListOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
- bool visitEnter(TupleTypeNavigator& type, const std::string& key, ListDataNavigator& data) override
+ void visitTupleOnEnter(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return _visitEnter(key, sanitizeTypeName(type.getName()), data.childrenSize());
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+ _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
}
- bool visitExit(TupleTypeNavigator&, ListDataNavigator&) override
+ void visitTupleOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
{
- return _visitExit();
+ _visitExit();
}
+ // What about Pair??
- bool visit(BoolTypeNavigator& type, const std::string& key, BoolDataNavigator& data) override
+ void visitBool(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Bool::DynamicCastAndCheck(data);
+ auto t = *aron::type::Bool::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(DoubleTypeNavigator& type, const std::string& key, DoubleDataNavigator& data) override
+ void visitDouble(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Double::DynamicCastAndCheck(data);
+ auto t = *aron::type::Double::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(FloatTypeNavigator& type, const std::string& key, FloatDataNavigator& data) override
+ void visitFloat(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Float::DynamicCastAndCheck(data);
+ auto t = *aron::type::Float::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(IntTypeNavigator& type, const std::string& key, IntDataNavigator& data) override
+ void visitInt(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Int::DynamicCastAndCheck(data);
+ auto t = *aron::type::Int::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(LongTypeNavigator& type, const std::string& key, LongDataNavigator& data) override
+ void visitLong(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Long::DynamicCastAndCheck(data);
+ auto t = *aron::type::Long::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(StringTypeNavigator& type, const std::string& key, StringDataNavigator& data) override
+ void visitString(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::String::DynamicCastAndCheck(data);
+ auto t = *aron::type::String::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(TimeTypeNavigator& type, const std::string& key, LongDataNavigator& data) override
+ void visitTime(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::Long::DynamicCastAndCheck(data);
+ auto t = *aron::type::Time::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(EigenMatrixTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
- {
- return this->addValueRow(key, data, type);
- }
- bool visit(EigenQuaternionTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitMatrix(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Matrix::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(IVTCByteImageTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitQuaternion(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Quaternion::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(OpenCVMatTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitPointCloud(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::PointCloud::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(PCLPointCloudTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitPose(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Pose::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(PoseTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitPosition(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Position::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(PositionTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitImage(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Image::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
- bool visit(OrientationTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data) override
+ void visitOrientation(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
{
- return this->addValueRow(key, data, type);
+ ARMARX_CHECK_NOT_NULL(data);
+ ARMARX_CHECK_NOT_NULL(type);
+ const std::string key = data->getPath().getLastElement();
+
+ auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
+ auto t = *aron::type::Orientation::DynamicCastAndCheck(type);
+ this->addValueRow(key, d, t);
}
+ // What aboud NDArray
protected:
template <class DataNavigatorT, class TypeNavigatorT>
- bool addValueRow(const std::string& key, DataNavigatorT& data, const TypeNavigatorT& type)
+ bool addValueRow(const std::string& key, const DataNavigatorT& data, const TypeNavigatorT& type)
{
if (items.size() > 0)
{
@@ -142,7 +236,7 @@ namespace armarx::armem::gui::instance
item->setData(columnKey, Qt::UserRole, serializePath(data.getPath()));
item->setData(columnType, Qt::UserRole, int(type.getDescriptor()));
- if (false)
+ if (false) // remove?
{
QFont font;
font.setFamily("Consolas");
@@ -156,7 +250,7 @@ namespace armarx::armem::gui::instance
}
template <class DataNavigatorT, class TypeNavigatorT>
- QTreeWidgetItem* makeItem(const std::string& key, DataNavigatorT& data, const TypeNavigatorT& type) const
+ QTreeWidgetItem* makeItem(const std::string& key, const DataNavigatorT& data, const TypeNavigatorT& type) const
{
std::stringstream ss;
try
@@ -171,14 +265,14 @@ namespace armarx::armem::gui::instance
es << e.what();
ss << simox::alg::replace_all(es.str(), "\n", " | ");
}
- return new QTreeWidgetItem(this->makeValueRowStrings(key, ss.str(), sanitizeTypeName(type.getName())));
+ return new QTreeWidgetItem(this->makeValueRowStrings(key, ss.str(), sanitizeTypeName(type.getFullName())));
}
- QTreeWidgetItem* makeItem(const std::string& key, NDArrayDataNavigator& data, const PoseTypeNavigator& type) const;
+ QTreeWidgetItem* makeItem(const std::string& key, aron::data::NDArray& data, const aron::type::Pose& type) const;
template <class DataNavigatorT, class TypeNavigatorT>
- void streamValueText(DataNavigatorT& data, const TypeNavigatorT& type, std::stringstream& ss) const
+ void streamValueText(const DataNavigatorT& data, const TypeNavigatorT& type, std::stringstream& ss) const
{
// Fallback to type-agnostic (but data-aware).
(void) type;
@@ -186,10 +280,10 @@ namespace armarx::armem::gui::instance
}
using TreeDataVisitorBase::streamValueText;
- void streamValueText(LongDataNavigator& data, const TimeTypeNavigator& type, std::stringstream& ss) const;
- void streamValueText(NDArrayDataNavigator& data, const PoseTypeNavigator& type, std::stringstream& ss) const;
- void streamValueText(NDArrayDataNavigator& data, const PositionTypeNavigator& type, std::stringstream& ss) const;
- void streamValueText(NDArrayDataNavigator& data, const OrientationTypeNavigator& type, std::stringstream& ss) const;
+ void streamValueText(const aron::data::Long& data, const aron::type::Time& type, std::stringstream& ss) const;
+ void streamValueText(const aron::data::NDArray& data, const aron::type::Pose& type, std::stringstream& ss) const;
+ void streamValueText(const aron::data::NDArray& data, const aron::type::Position& type, std::stringstream& ss) const;
+ void streamValueText(const aron::data::NDArray& data, const aron::type::Orientation& type, std::stringstream& ss) const;
std::string coeffSep = " ";
diff --git a/source/RobotAPI/libraries/armem_gui/memory/TreeWidget.cpp b/source/RobotAPI/libraries/armem_gui/memory/TreeWidget.cpp
index 1ff5b509001d5cdb4d095442b4614878396b4157..0ece75cfb419df323a3269a7baacb8d3e4fbba6e 100644
--- a/source/RobotAPI/libraries/armem_gui/memory/TreeWidget.cpp
+++ b/source/RobotAPI/libraries/armem_gui/memory/TreeWidget.cpp
@@ -2,7 +2,7 @@
#include <RobotAPI/libraries/armem_gui/instance/sanitize_typename.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
#include <SimoxUtility/algorithm/string.h>
@@ -310,7 +310,7 @@ namespace armarx::armem::gui::memory
std::string typeName;
if (cast.aronType())
{
- typeName = cast.aronType()->getName();
+ typeName = cast.aronType()->getFullName();
typeName = instance::sanitizeTypeName(typeName);
}
else
diff --git a/source/RobotAPI/libraries/armem_gui/test/ArMemGuiTest.cpp b/source/RobotAPI/libraries/armem_gui/test/ArMemGuiTest.cpp
index f7bb3e3e9a4cdc560838c0a3d25c0d7074a96503..557cb075dc6a7f80a82711eb3dace2afc1914f5d 100644
--- a/source/RobotAPI/libraries/armem_gui/test/ArMemGuiTest.cpp
+++ b/source/RobotAPI/libraries/armem_gui/test/ArMemGuiTest.cpp
@@ -30,11 +30,11 @@
#include <iostream>
#include <RobotAPI/libraries/armem_gui/instance/sanitize_typename.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
-namespace dn = armarx::aron::datanavigator;
-namespace tn = armarx::aron::typenavigator;
+namespace dn = armarx::aron::data;
+namespace tn = armarx::aron::type;
namespace ArMemGuiTest
@@ -60,69 +60,63 @@ BOOST_FIXTURE_TEST_SUITE(ArMemGuiTest, ArMemGuiTest::Fixture)
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_int)
{
- test_sanitize(tn::IntNavigator().getName(), "Int");
- test_sanitize(dn::IntNavigator().getName(), "Int");
+ test_sanitize(tn::Int().getFullName(), "Int");
+ test_sanitize(dn::Int().getFullName(), "Int");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_float)
{
- test_sanitize(tn::FloatNavigator().getName(), "Float");
- test_sanitize(dn::FloatNavigator().getName(), "Float");
+ test_sanitize(tn::Float().getFullName(), "Float");
+ test_sanitize(dn::Float().getFullName(), "Float");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_dict)
{
- tn::DictNavigator dict;
- dict.setAcceptedType(std::make_shared<tn::FloatNavigator>());
- test_sanitize(dict.getName(), "Dict<Float>");
+ tn::Dict dict(std::make_shared<tn::Float>());
+ test_sanitize(dict.getFullName(), "Dict<Float>");
- test_sanitize(dn::DictNavigator().getName(), "Dict");
+ test_sanitize(dn::Dict().getFullName(), "Dict");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_list)
{
- tn::ListNavigator list;
- list.setAcceptedType(std::make_shared<tn::LongNavigator>());
- test_sanitize(list.getName(), "List<Long>");
+ tn::List list(std::make_shared<tn::Long>());
+ test_sanitize(list.getFullName(), "List<Long>");
- test_sanitize(dn::ListNavigator().getName(), "List");
+ test_sanitize(dn::List().getFullName(), "List");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_object)
{
- tn::ObjectNavigator obj;
- obj.setObjectName("namespace::MyObjectName");
- test_sanitize(obj.getName(), "MyObjectName (namespace)");
+ tn::Object obj("namespace::MyObjectName", std::map<std::string, tn::VariantPtr>());
+ test_sanitize(obj.getFullName(), "MyObjectName (namespace)");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_tuple)
{
- tn::TupleNavigator type;
- type.addAcceptedType(std::make_shared<tn::IntNavigator>());
- type.addAcceptedType(std::make_shared<tn::FloatNavigator>());
- test_sanitize(type.getName(), "Tuple<Int, Float>");
+ std::vector<tn::VariantPtr> ac = {std::make_shared<tn::Int>(), std::make_shared<tn::Float>()};
+ tn::Tuple type(ac);
+ test_sanitize(type.getFullName(), "Tuple<Int, Float>");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_pair)
{
- tn::PairNavigator type;
- type.setFirstAcceptedType(std::make_shared<tn::IntNavigator>());
- type.setSecondAcceptedType(std::make_shared<tn::FloatNavigator>());
- test_sanitize(type.getName(), "Pair<Int, Float>");
+ tn::Pair type(std::make_shared<tn::Int>(), std::make_shared<tn::Float>());
+ test_sanitize(type.getFullName(), "Pair<Int, Float>");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_ndarry)
{
{
- tn::NDArrayNavigator type;
- type.setDimensions({ 3, 2, 1});
- type.setTypename("float");
- test_sanitize(type.getName(), "NDArray");
+ tn::NDArray type;
+ type.setNumberDimensions(3); //old: { 3, 2, 1});
+ type.setElementType(armarx::aron::type::ndarray::float32);
+ test_sanitize(type.getFullName(), "NDArray");
}
{
- dn::NDArrayNavigator data;
- data.setDimensions({ 3, 2, 1});
- test_sanitize(data.getName(), "NDArray<3, 2, 1, >");
+ dn::NDArray data;
+ data.setShape({ 3, 2, 1});
+ test_sanitize(data.getFullName(), "NDArray<3, 2, 1, >");
}
}
diff --git a/source/RobotAPI/libraries/armem_motions/server/MotionDatabase/MDBMotions/MotionConverter.cpp b/source/RobotAPI/libraries/armem_motions/server/MotionDatabase/MDBMotions/MotionConverter.cpp
index 31f28ea09b62d687fbcb3871941bc3ab9bd329a1..f8019e8a8daf4421b48b81498bcc7cedce0cb8f4 100644
--- a/source/RobotAPI/libraries/armem_motions/server/MotionDatabase/MDBMotions/MotionConverter.cpp
+++ b/source/RobotAPI/libraries/armem_motions/server/MotionDatabase/MDBMotions/MotionConverter.cpp
@@ -1,6 +1,9 @@
// Header
#include "MotionConverter.h"
+#include <SimoxUtility/json/json.hpp>
+
+
namespace armarx::armem::server::motions::mdb::conversion
{
std::optional<armem::mdb::MDBReference> createFromFile(const std::filesystem::path& pathToInfoJson)
diff --git a/source/RobotAPI/libraries/armem_robot_state/aron/Proprioception.xml b/source/RobotAPI/libraries/armem_robot_state/aron/Proprioception.xml
index 99900b7b0766613a555fb060fa19fddf987def7f..da176a1f9224e986b510abd5f73286f84d3e3802 100644
--- a/source/RobotAPI/libraries/armem_robot_state/aron/Proprioception.xml
+++ b/source/RobotAPI/libraries/armem_robot_state/aron/Proprioception.xml
@@ -101,20 +101,20 @@
<ObjectChild key="orientation">
<Dict>
- <EigenMatrix rows="4" cols="1" type="float" />
+ <Matrix rows="4" cols="1" type="float32" />
<!--Orientation /-->
</Dict>
</ObjectChild>
<ObjectChild key="angularVelocity">
<Dict>
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</Dict>
</ObjectChild>
<ObjectChild key="linearAcceleration">
<Dict>
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</Dict>
</ObjectChild>
@@ -184,20 +184,20 @@
<Object name="armarx::armem::prop::arondto::Platform">
<ObjectChild key="relativePosition">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<!-- Global pose is not part of proprioception. -->
<!--ObjectChild key="absolutePosition">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild-->
<ObjectChild key="velocity">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="acceleration">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="extra">
@@ -212,19 +212,19 @@
<Object name="armarx::armem::prop::arondto::ForceTorque">
<ObjectChild key="force">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="torque">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="gravityCompensationForce">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="gravityCompensationTorque">
- <EigenMatrix rows="3" cols="1" type="float" />
+ <Matrix rows="3" cols="1" type="float32" />
</ObjectChild>
<ObjectChild key="extra">
diff --git a/source/RobotAPI/libraries/armem_robot_state/client/common/RobotReader.cpp b/source/RobotAPI/libraries/armem_robot_state/client/common/RobotReader.cpp
index 2cd6bad5240f6e5a4dbbb436711fcf6bfb439abc..92c5039cadbc9015af4a2488500869ed197b0362 100644
--- a/source/RobotAPI/libraries/armem_robot_state/client/common/RobotReader.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/client/common/RobotReader.cpp
@@ -5,16 +5,17 @@
#include "ArmarXCore/core/exceptions/local/ExpressionException.h"
#include "RobotAPI/libraries/armem_robot/types.h"
-#include <ArmarXCore/core/PackagePath.h>
#include <ArmarXCore/core/exceptions/LocalException.h>
#include <ArmarXCore/core/logging/Logging.h>
+#include <ArmarXCore/core/PackagePath.h>
+
#include <RobotAPI/libraries/armem/client/query/Builder.h>
-#include <RobotAPI/libraries/armem/core/Time.h>
#include <RobotAPI/libraries/armem/core/error.h>
+#include <RobotAPI/libraries/armem/core/Time.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
-#include <RobotAPI/libraries/armem_robot/aron/Robot.aron.generated.h>
#include <RobotAPI/libraries/armem_robot/aron_conversions.h>
#include <RobotAPI/libraries/armem_robot/robot_conversions.h>
+#include <RobotAPI/libraries/armem_robot/aron/Robot.aron.generated.h>
#include <RobotAPI/libraries/armem_robot_state/aron/JointState.aron.generated.h>
#include <RobotAPI/libraries/armem_robot_state/aron/Proprioception.aron.generated.h>
#include <RobotAPI/libraries/armem_robot_state/aron_conversions.h>
@@ -53,8 +54,7 @@ namespace armarx::armem::robot_state
try
{
memoryReader = memoryNameSystem.useReader(properties.memoryName);
- ARMARX_IMPORTANT << "RobotReader: Connected to memory '" << properties.memoryName
- << "'";
+ ARMARX_IMPORTANT << "RobotReader: Connected to memory '" << properties.memoryName << "'";
}
catch (const armem::error::CouldNotResolveMemoryServer& e)
{
@@ -81,9 +81,9 @@ namespace armarx::armem::robot_state
RobotReader::get(const robot::RobotDescription& description, const armem::Time& timestamp)
{
robot::Robot robot{.description = description,
- .instance = "", // TODO(fabian.reister):
- .config = {}, // will be populated by synchronize
- .timestamp = timestamp};
+ .instance = "", // TODO(fabian.reister):
+ .config = {}, // will be populated by synchronize
+ .timestamp = timestamp};
synchronize(robot, timestamp);
@@ -300,13 +300,11 @@ namespace armarx::armem::robot_state
// clang-format on
const armem::wm::EntityInstance* instance = nullptr;
- providerSegment.forEachInstance(
- [&instance](const wm::EntityInstance& i)
- {
- instance = &i;
- return false; // break
- });
-
+ providerSegment.forEachInstance([&instance](const wm::EntityInstance & i)
+ {
+ instance = &i;
+ return false; // break
+ });
if (!instance)
{
ARMARX_WARNING << "No entity snapshots found";
@@ -322,13 +320,11 @@ namespace armarx::armem::robot_state
std::optional<AronClass>
tryCast(const wm::EntityInstance& item)
{
- static_assert(std::is_base_of<armarx::aron::cppserializer::AronCppClass, AronClass>::value);
+ static_assert(std::is_base_of<armarx::aron::codegenerator::cpp::AronCppClass, AronClass>::value);
try
{
- AronClass t;
- t.fromAron(item.data());
- return t;
+ return AronClass::FromAron(item.data());
}
catch (const armarx::aron::error::AronException&)
{
@@ -348,29 +344,27 @@ namespace armarx::armem::robot_state
.getCoreSegment(properties.proprioceptionCoreSegment);
// clang-format on
- coreSegment.forEachEntity(
- [&jointMap](const wm::Entity& entity)
- {
- const auto& entityInstance = entity.getLatestSnapshot().getInstance(0);
+ coreSegment.forEachEntity([&jointMap](const wm::Entity & entity)
+ {
+ const auto& entityInstance = entity.getLatestSnapshot().getInstance(0);
- const auto proprioception =
- tryCast<::armarx::armem::arondto::Proprioception>(entityInstance);
- ARMARX_CHECK(proprioception.has_value());
+ const auto proprioception = tryCast<::armarx::armem::arondto::Proprioception>(entityInstance);
+ ARMARX_CHECK(proprioception.has_value());
const armarx::armem::prop::arondto::Joints& joints = proprioception->joints;
- // const auto jointState = tryCast<::armarx::armem::arondto::JointState>(entityInstance);
- // if (not jointState)
- // {
- // ARMARX_WARNING << "Could not convert entity instance to 'JointState'";
- // return;
- // }
+ // const auto jointState = tryCast<::armarx::armem::arondto::JointState>(entityInstance);
+ // if (not jointState)
+ // {
+ // ARMARX_WARNING << "Could not convert entity instance to 'JointState'";
+ // return;
+ // }
- jointMap = joints.position;
+ jointMap = joints.position;
- // jointMap.emplace(jointState->name, jointState->position);
- });
+ // jointMap.emplace(jointState->name, jointState->position);
+ });
if (jointMap.empty())
{
diff --git a/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformReader.cpp b/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformReader.cpp
index d46c7dfa1cc72847b27a820ecd4281ec1cb649e6..2b2c942490e2b7527552881cbf1be5e8a4c11cff 100644
--- a/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformReader.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformReader.cpp
@@ -53,7 +53,9 @@
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
#include <RobotAPI/libraries/armem/server/MemoryRemoteGui.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h>
+
+#include <RobotAPI/libraries/aron/core/type/variant/Factory.h>
+
#include <RobotAPI/libraries/armem_robot_state/aron_conversions.h>
#include <RobotAPI/libraries/armem_robot_state/aron/Transform.aron.generated.h>
#include <RobotAPI/libraries/armem_robot_state/common/localization/types.h>
diff --git a/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformWriter.cpp b/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformWriter.cpp
index 608dfa3947153985dc4f528bb0746ab95df706fc..ba34586a1e77390efbecd18abba1e726db6f7467 100644
--- a/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformWriter.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/client/localization/TransformWriter.cpp
@@ -41,7 +41,7 @@
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
#include <RobotAPI/libraries/armem/server/MemoryRemoteGui.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Factory.h>
#include <RobotAPI/libraries/core/FramedPose.h>
#include <RobotAPI/libraries/armem_robot_state/aron/Transform.aron.generated.h>
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.cpp
index 9b35f938d421e0662452ea5d6f49be87390553d2..c8a06a1b8329cb3df77280b1da18da556900ae93 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.cpp
@@ -34,7 +34,7 @@
#include <ArmarXCore/libraries/ArmarXCoreComponentPlugins/DebugObserverComponentPlugin.h>
#include <RobotAPI/libraries/core/FramedPose.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
#include <RobotAPI/libraries/armem/core/Time.h>
#include <RobotAPI/libraries/armem/core/ice_conversions.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
@@ -159,7 +159,7 @@ namespace armarx::armem::server::robot_state::proprioception
if (data.proprioception->hasElement(platformKey))
{
ARMARX_DEBUG << "Found odometry data.";
- auto platformData = aron::datanavigator::DictNavigator::DynamicCastAndCheck(data.proprioception->getElement(platformKey));
+ auto platformData = aron::data::Dict::DynamicCastAndCheck(data.proprioception->getElement(platformKey));
update.localization.emplace_back(getTransform(platformData, data.timestamp));
}
else
@@ -182,7 +182,7 @@ namespace armarx::armem::server::robot_state::proprioception
armem::robot_state::Transform
RobotStateWriter::getTransform(
- const aron::datanavigator::DictNavigatorPtr& platformData,
+ const aron::data::DictPtr& platformData,
const Time& timestamp) const
{
prop::arondto::Platform platform;
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.h b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.h
index 1f66d5a7010e7c925513ab0463269261251ca434..4a4f14672b038132243bdbd5fc5a5617f3f5d668 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.h
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.h
@@ -76,7 +76,7 @@ namespace armarx::armem::server::robot_state::proprioception
armem::robot_state::Transform
getTransform(
- const aron::datanavigator::DictNavigatorPtr& platformData,
+ const aron::data::DictPtr& platformData,
const Time& timestamp) const;
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.cpp
index 4262bf76e634ff03445a7460cd4fd55a4df861d9..71e493d96d1386be1993bf5991b869e764b898b7 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.cpp
@@ -1,8 +1,5 @@
#include "RobotUnitData.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-
-
namespace armarx::armem::server::robot_state::proprioception
{
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.h b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.h
index 4045742af416c96ad2d101d98f4559d8cef1dce9..c0029b4fbccece40156be49f05ca1efa4215850c 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.h
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitData.h
@@ -2,21 +2,16 @@
#include <memory>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/armem/core/Time.h>
-
-namespace armarx::aron::datanavigator
-{
- using DictNavigatorPtr = std::shared_ptr<class DictNavigator>;
-}
namespace armarx::armem::server::robot_state::proprioception
{
struct RobotUnitData
{
Time timestamp;
- aron::datanavigator::DictNavigatorPtr proprioception;
+ aron::data::DictPtr proprioception;
};
-
}
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitReader.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitReader.cpp
index 4fb42da5e5fa804fad70b3978766323a487ad1fb..12638d84e18a8a3439b560fb9e2287c3fe233c79 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitReader.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotUnitReader.cpp
@@ -4,9 +4,9 @@
#include <RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h>
#include <RobotAPI/libraries/armem_robot_state/aron/Proprioception.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/primitive/Long.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/primitive/String.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/primitive/Long.h>
+#include <RobotAPI/libraries/aron/core/data/variant/primitive/String.h>
#include <RobotAPI/libraries/RobotUnitDataStreamingReceiver/RobotUnitDataStreamingReceiver.h>
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/Segment.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/Segment.cpp
index 6321dd355bb6defc1f7bb19fbbdebcf77976aba2..28d1ca4e0ce68a2936968c8d204e125baa3ee5c7 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/Segment.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/Segment.cpp
@@ -7,7 +7,7 @@
#include <ArmarXCore/libraries/DebugObserverHelper/DebugObserverHelper.h>
#include <ArmarXCore/observers/ObserverObjectFactories.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem_robot_state/aron/Proprioception.aron.generated.h>
@@ -56,12 +56,12 @@ namespace armarx::armem::server::robot_state::proprioception
static
- aron::datanavigator::DictNavigatorPtr
- getDictElement(const aron::datanavigator::DictNavigator& dict, const std::string& key)
+ aron::data::DictPtr
+ getDictElement(const aron::data::Dict& dict, const std::string& key)
{
if (dict.hasElement(key))
{
- return aron::datanavigator::DictNavigator::DynamicCastAndCheck(dict.getElement(key));
+ return aron::data::Dict::DynamicCastAndCheck(dict.getElement(key));
}
return nullptr;
}
@@ -72,7 +72,7 @@ namespace armarx::armem::server::robot_state::proprioception
const armem::Time& timestamp,
DebugObserverHelper* debugObserver) const
{
- namespace adn = aron::datanavigator;
+ namespace adn = aron::data;
ARMARX_CHECK_NOT_NULL(segment);
RobotJointPositionMap jointMap;
@@ -82,7 +82,7 @@ namespace armarx::armem::server::robot_state::proprioception
TIMING_START(tProcessEntities)
segment->forEachEntity([&](const wm::Entity & entity)
{
- adn::DictNavigatorPtr data;
+ adn::DictPtr data;
{
TIMING_START(_tFindData)
@@ -133,17 +133,17 @@ namespace armarx::armem::server::robot_state::proprioception
std::map<std::string, float>
Segment::readJointPositions(const wm::EntityInstanceData& data)
{
- namespace adn = aron::datanavigator;
+ namespace adn = aron::data;
// Just get what we need without casting the whole data.
std::map<std::string, float> jointPositions;
- if (adn::DictNavigatorPtr joints = getDictElement(data, "joints"))
+ if (adn::DictPtr joints = getDictElement(data, "joints"))
{
- if (adn::DictNavigatorPtr jointsPosition = getDictElement(*joints, "position"))
+ if (adn::DictPtr jointsPosition = getDictElement(*joints, "position"))
{
for (const auto& [name, value] : jointsPosition->getElements())
{
- const float jointPosition = adn::FloatNavigator::DynamicCastAndCheck(value)->getValue();
+ const float jointPosition = adn::Float::DynamicCastAndCheck(value)->getValue();
jointPositions[name] = jointPosition;
}
}
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.cpp
index 8caf73057ac54df453f6e3c2d67295dc7e69ab89..888c68c7313b10c775e81512c3fdc414844c4025 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.cpp
@@ -1,6 +1,6 @@
#include "aron_conversions.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
#include <RobotAPI/libraries/RobotUnitDataStreamingReceiver/RobotUnitDataStreamingReceiver.h>
#include <ArmarXCore/core/exceptions/local/UnexpectedEnumValueException.h>
@@ -8,7 +8,7 @@
namespace armarx
{
- aron::datanavigator::NavigatorPtr RobotUnitDataStreaming::toAron(
+ aron::data::VariantPtr RobotUnitDataStreaming::toAron(
const TimeStep& timestep,
const DataEntry& dataEntry)
{
@@ -17,37 +17,37 @@ namespace armarx
case RobotUnitDataStreaming::NodeTypeFloat:
{
float value = RobotUnitDataStreamingReceiver::GetAs<Ice::Float>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::FloatNavigator>(value);
+ return std::make_shared<aron::data::Float>(value);
}
case RobotUnitDataStreaming::NodeTypeBool:
{
bool value = RobotUnitDataStreamingReceiver::GetAs<bool>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::BoolNavigator>(value);
+ return std::make_shared<aron::data::Bool>(value);
}
case RobotUnitDataStreaming::NodeTypeByte:
{
int value = RobotUnitDataStreamingReceiver::GetAs<Ice::Byte>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::IntNavigator>(value);
+ return std::make_shared<aron::data::Int>(value);
}
case RobotUnitDataStreaming::NodeTypeShort:
{
int value = RobotUnitDataStreamingReceiver::GetAs<Ice::Short>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::IntNavigator>(value);
+ return std::make_shared<aron::data::Int>(value);
}
case RobotUnitDataStreaming::NodeTypeInt:
{
int value = RobotUnitDataStreamingReceiver::GetAs<Ice::Int>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::IntNavigator>(value);
+ return std::make_shared<aron::data::Int>(value);
}
case RobotUnitDataStreaming::NodeTypeLong:
{
long value = RobotUnitDataStreamingReceiver::GetAs<Ice::Long>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::LongNavigator>(value);
+ return std::make_shared<aron::data::Long>(value);
}
case RobotUnitDataStreaming::NodeTypeDouble:
{
double value = RobotUnitDataStreamingReceiver::GetAs<Ice::Double>(timestep, dataEntry);
- return std::make_shared<aron::datanavigator::DoubleNavigator>(value);
+ return std::make_shared<aron::data::Double>(value);
}
default:
ARMARX_UNEXPECTED_ENUM_VALUE(RobotUnitDataStreaming::NodeType, dataEntry.type);
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h
index dd2177c9e2f167af3946119f381dcd7ec43d170c..6f317faeb8c17a987e3b199a3f935028ae7ef770 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h
@@ -4,17 +4,13 @@
#include <SimoxUtility/meta/enum/EnumNames.hpp>
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
#include <RobotAPI/interface/units/RobotUnit/RobotUnitInterface.h>
-namespace armarx::aron::datanavigator
-{
- using NavigatorPtr = std::shared_ptr<class Navigator>;
-}
-
namespace armarx::RobotUnitDataStreaming
{
- aron::datanavigator::NavigatorPtr toAron(
+ aron::data::VariantPtr toAron(
const TimeStep& timestep,
const DataEntry& dataEntry);
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.cpp
index cb1192954cf52fedeec2040e161c72fae15479c6..9b7c4fea29c8d2bd2471ca13feca3c384e194433 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.cpp
@@ -4,7 +4,7 @@
#include <SimoxUtility/algorithm/advanced.h>
#include <RobotAPI/libraries/RobotUnitDataStreamingReceiver/RobotUnitDataStreamingReceiver.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/armem_robot_state/server/proprioception/aron_conversions.h>
@@ -25,7 +25,7 @@ namespace armarx::armem::server::robot_state::proprioception
}
- aron::datanavigator::DictNavigatorPtr
+ aron::data::DictPtr
Armar6Converter::convert(
const RobotUnitDataStreaming::TimeStep& data,
const RobotUnitDataStreaming::DataStreamingDescription& description)
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.h b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.h
index 03c0a05d0387cae6faba1a0a779ba874a3006730..2ae2f7ebcfa93fa2fcced476aee2bb1a8ec46569 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.h
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/Armar6Converter.h
@@ -25,7 +25,7 @@ namespace armarx::armem::server::robot_state::proprioception
virtual ~Armar6Converter() override;
- aron::datanavigator::DictNavigatorPtr
+ aron::data::DictPtr
convert(
const RobotUnitDataStreaming::TimeStep& data,
const RobotUnitDataStreaming::DataStreamingDescription& description) override;
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterInterface.h b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterInterface.h
index 1162623895611e89d69740f6bf7d014c325f1427..d7f7855245dd373185bd2d34a8817e21b0a33f01 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterInterface.h
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterInterface.h
@@ -2,6 +2,7 @@
#include <memory>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
namespace armarx::RobotUnitDataStreaming
{
@@ -13,10 +14,6 @@ namespace armarx::armem::arondto
{
class Proprioception;
}
-namespace armarx::aron::datanavigator
-{
- using DictNavigatorPtr = std::shared_ptr<class DictNavigator>;
-}
namespace armarx::armem::server::robot_state::proprioception
{
@@ -27,7 +24,7 @@ namespace armarx::armem::server::robot_state::proprioception
virtual ~ConverterInterface();
virtual
- aron::datanavigator::DictNavigatorPtr convert(
+ aron::data::DictPtr convert(
const RobotUnitDataStreaming::TimeStep& data,
const RobotUnitDataStreaming::DataStreamingDescription& description) = 0;
diff --git a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterTools.cpp b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterTools.cpp
index 7cc2fc128b55dc9af794804cc569d91b75ba7071..d8483d22fbf836afec34991064d9f6070496b7de 100644
--- a/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterTools.cpp
+++ b/source/RobotAPI/libraries/armem_robot_state/server/proprioception/converters/ConverterTools.cpp
@@ -4,7 +4,7 @@
#include <SimoxUtility/algorithm/advanced.h>
#include <RobotAPI/libraries/RobotUnitDataStreamingReceiver/RobotUnitDataStreamingReceiver.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
namespace armarx::armem::server::robot_state
diff --git a/source/RobotAPI/libraries/armem_skills/CMakeLists.txt b/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
index bb6968ecb11991511f67f464843683a5bbacc8ef..49add11dbd3ef1bfbc68b9adc2cc0abe75935af4 100644
--- a/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
+++ b/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
@@ -19,12 +19,11 @@ armarx_add_library(
./StatechartListener.h
)
-
armarx_enable_aron_file_generation_for_target(
TARGET_NAME
- "${LIB_NAME}"
+ "${LIB_NAME}"
ARON_FILES
- aron/Statechart.xml
+ aron/Statechart.xml
)
diff --git a/source/RobotAPI/libraries/armem_skills/aron_conversions.cpp b/source/RobotAPI/libraries/armem_skills/aron_conversions.cpp
index db18f5ac2a93db5a20b5103aff547e607ff6c29d..579e295614d35d0e4584db6c185194c5c95ab008 100644
--- a/source/RobotAPI/libraries/armem_skills/aron_conversions.cpp
+++ b/source/RobotAPI/libraries/armem_skills/aron_conversions.cpp
@@ -4,20 +4,20 @@ namespace armarx::armem
{
std::map<armarx::eStateType, armarx::armem::arondto::Statechart::StateType> toAronStateTypeMap =
{
- {eNormalState, armarx::armem::arondto::Statechart::StateType::NORMAL},
- {eFinalState, armarx::armem::arondto::Statechart::StateType::FINAL},
- {eRemoteState, armarx::armem::arondto::Statechart::StateType::REMOTE},
- {eDynamicRemoteState, armarx::armem::arondto::Statechart::StateType::DYNAMIC_REMOTE},
- {eUndefined, armarx::armem::arondto::Statechart::StateType::UNDEFINED},
+ {eNormalState, (armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::NORMAL},
+ {eFinalState, (armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::FINAL},
+ {eRemoteState, (armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::REMOTE},
+ {eDynamicRemoteState, (armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::DYNAMIC_REMOTE},
+ {eUndefined, (armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::UNDEFINED},
};
std::map<armarx::armem::arondto::Statechart::StateType, armarx::eStateType> fromAronStateTypeMap =
{
- {armarx::armem::arondto::Statechart::StateType::NORMAL, eNormalState},
- {armarx::armem::arondto::Statechart::StateType::FINAL, eFinalState},
- {armarx::armem::arondto::Statechart::StateType::REMOTE, eRemoteState},
- {armarx::armem::arondto::Statechart::StateType::DYNAMIC_REMOTE, eDynamicRemoteState},
- {armarx::armem::arondto::Statechart::StateType::UNDEFINED, eUndefined},
+ {(armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::NORMAL, eNormalState},
+ {(armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::FINAL, eFinalState},
+ {(armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::REMOTE, eRemoteState},
+ {(armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::DYNAMIC_REMOTE, eDynamicRemoteState},
+ {(armarx::armem::arondto::Statechart::StateType) armarx::armem::arondto::Statechart::StateType::UNDEFINED, eUndefined},
};
void fromAron(const arondto::Statechart::StateType& dto, eStateType& bo)
@@ -85,4 +85,4 @@ namespace armarx::armem
toAron(dto.localParameters, bo.localParameters);
toAron(dto.outputParameters, bo.outputParameters);
}
-}
\ No newline at end of file
+}
diff --git a/source/RobotAPI/libraries/armem_vision/aron_conversions.cpp b/source/RobotAPI/libraries/armem_vision/aron_conversions.cpp
index 47ada08bb62a3ae78fe9520255be23b1f92e7612..b4caa2632769a098c970b7ec378bceb49e54f051 100644
--- a/source/RobotAPI/libraries/armem_vision/aron_conversions.cpp
+++ b/source/RobotAPI/libraries/armem_vision/aron_conversions.cpp
@@ -8,7 +8,7 @@
#include <RobotAPI/libraries/armem_vision/aron/LaserScan.aron.generated.h>
#include <RobotAPI/libraries/aron/common/aron_conversions.h>
#include <RobotAPI/libraries/aron/converter/common/Converter.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
#include "types.h"
diff --git a/source/RobotAPI/libraries/armem_vision/aron_conversions.h b/source/RobotAPI/libraries/armem_vision/aron_conversions.h
index db97ad5076457805d953100201821f912a046291..53527f2b5ad9357c8f9bd627b2c3d83793e7c9a8 100644
--- a/source/RobotAPI/libraries/armem_vision/aron_conversions.h
+++ b/source/RobotAPI/libraries/armem_vision/aron_conversions.h
@@ -27,7 +27,7 @@
#include <RobotAPI/libraries/armem_vision/aron/OccupancyGrid.aron.generated.h>
#include <RobotAPI/libraries/aron/converter/common/VectorConverter.h>
#include <RobotAPI/libraries/aron/converter/eigen/EigenConverter.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::armem
{
@@ -47,7 +47,7 @@ namespace armarx::armem
std::string& agentName);
template <typename T>
- auto fromAron(const aron::datanavigator::NDArrayNavigatorPtr& navigator)
+ auto fromAron(const aron::data::NDArrayPtr& navigator)
{
return aron::converter::AronVectorConverter::ConvertToVector<T>(
navigator);
@@ -62,7 +62,7 @@ namespace armarx::armem
const std::string& agentName,
arondto::LaserScanStamped& aronLaserScan);
- inline aron::datanavigator::NDArrayNavigatorPtr
+ inline aron::data::NDArrayPtr
toAron(const LaserScan& laserScan)
{
using aron::converter::AronVectorConverter;
@@ -73,7 +73,7 @@ namespace armarx::armem
void toAron(arondto::OccupancyGrid& dto, const OccupancyGrid& bo);
void fromAron(const arondto::OccupancyGrid& dto, OccupancyGrid& bo);
- inline aron::datanavigator::NDArrayNavigatorPtr
+ inline aron::data::NDArrayPtr
toAron(const OccupancyGrid::Grid& grid)
{
return aron::converter::AronEigenConverter::ConvertFromArray(grid);
diff --git a/source/RobotAPI/libraries/armem_vision/client/laser_scans/Reader.cpp b/source/RobotAPI/libraries/armem_vision/client/laser_scans/Reader.cpp
index 4bc22306d7d26603d1edba2c8fc8f8aed40b1a8d..5faf563cfab3c4c380258268671f5c7268fe9dd1 100644
--- a/source/RobotAPI/libraries/armem_vision/client/laser_scans/Reader.cpp
+++ b/source/RobotAPI/libraries/armem_vision/client/laser_scans/Reader.cpp
@@ -30,7 +30,7 @@
// RobotAPI Aron
#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
// RobotAPI Armem
#include <RobotAPI/libraries/armem/core/error.h>
@@ -138,7 +138,7 @@ namespace armarx::armem::vision::laser_scans::client
fromAron(aronLaserScanStamped, laserScanStamped);
const auto ndArrayNavigator =
- aron::datanavigator::NDArrayNavigator::DynamicCast(
+ aron::data::NDArray::DynamicCast(
ei.data()->getElement("scan"));
ARMARX_CHECK_NOT_NULL(ndArrayNavigator);
diff --git a/source/RobotAPI/libraries/armem_vision/client/occupancy_grid/Reader.cpp b/source/RobotAPI/libraries/armem_vision/client/occupancy_grid/Reader.cpp
index fe59e94773e8f1a82396705e43be5e51c57c08b0..bb3bdf5546650f2bb8c45db39b092c0f601c2c9a 100644
--- a/source/RobotAPI/libraries/armem_vision/client/occupancy_grid/Reader.cpp
+++ b/source/RobotAPI/libraries/armem_vision/client/occupancy_grid/Reader.cpp
@@ -33,7 +33,7 @@
// RobotAPI Aron
#include <RobotAPI/libraries/armem_vision/aron/OccupancyGrid.aron.generated.h>
#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
// RobotAPI Armem
#include <RobotAPI/libraries/armem/client/Query.h>
@@ -102,7 +102,7 @@ namespace armarx::armem::vision::occupancy_grid::client
fromAron(*aronDto, occupancyGrid);
// direct access to grid data
- const auto ndArrayNavigator = aron::datanavigator::NDArrayNavigator::DynamicCast(
+ const auto ndArrayNavigator = aron::data::NDArray::DynamicCast(
entityInstance->data()->getElement("grid"));
ARMARX_CHECK_NOT_NULL(ndArrayNavigator);
diff --git a/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.cpp b/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.cpp
index 32a2572b24693176cee05121b89fcba025d66077..b1726ae052dd6bde6c90a3beaa7f18a8b966c1d5 100644
--- a/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.cpp
+++ b/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.cpp
@@ -31,7 +31,7 @@ namespace armarx
{
namespace aron
{
- namespace codegenerator
+ namespace codegenerator::cpp
{
}
diff --git a/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.h b/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.h
index f04a757684fc6e6d602d74f4f84f18413667e2fa..8783ca562067e030d0650615c7716722fd734acf 100644
--- a/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.h
+++ b/source/RobotAPI/libraries/aron/codegenerationhelper/AronCodeGenerator.h
@@ -32,7 +32,7 @@ namespace armarx
{
namespace aron
{
- namespace codegenerator
+ namespace codegenerator::cpp
{
/* This is just a dummy class to create a target which depends on the aron code generator executable. */
class AronCodeGenerator;
diff --git a/source/RobotAPI/libraries/aron/common/CMakeLists.txt b/source/RobotAPI/libraries/aron/common/CMakeLists.txt
index 491e3dec396e706dcacea61955ec59eb19a97245..4de720b5e85eb98c4f35703adc9bc78124243618 100644
--- a/source/RobotAPI/libraries/aron/common/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/common/CMakeLists.txt
@@ -25,14 +25,19 @@ armarx_add_library(
aron_conversions/simox.cpp
aron_conversions/stl.cpp
aron_conversions/eigen.cpp
+)
+
+armarx_enable_aron_file_generation_for_target(
+ TARGET_NAME
+ "${LIB_NAME}"
ARON_FILES
#aron/SimplePosition.xml
#aron/SimplePose.xml
#aron/SimpleTrajectory.xml
+ aron/PackagePath.xml
aron/AxisAlignedBoundingBox.xml
aron/OrientedBox.xml
- aron/PackagePath.xml
)
add_library(aron::common ALIAS aroncommon)
diff --git a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
index 78cce4a1a7d2d9b6d9f5fc9a1f156683c67c0d71..096e4830c37276c492d805515e47dd863301f545 100644
--- a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
@@ -30,7 +30,7 @@
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::aron::converter
@@ -41,20 +41,20 @@ namespace armarx::aron::converter
AronVectorConverter() = delete;
template<typename T>
- static std::vector<T> ConvertToVector(const datanavigator::NDArrayNavigatorPtr& nav)
+ static std::vector<T> ConvertToVector(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
- const auto& dims = nav->getDimensions();
+ const auto& dims = nav->getShape();
if (dims.size() != 2)
{
- throw error::AronException("AronVectorConverter", "ConvertToVector", "The NDArray must have two dimensions.", nav->getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have two dimensions.", nav->getPath());
}
if (dims.at(1) != sizeof(T))
{
- throw error::AronException("AronVectorConverter", "ConvertToVector", "Dimension 1 of the array has to match the element size.", nav->getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "Dimension 1 of the array has to match the element size.", nav->getPath());
}
const int size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<>());
@@ -67,11 +67,11 @@ namespace armarx::aron::converter
template<typename T>
- static datanavigator::NDArrayNavigatorPtr ConvertFromVector(const std::vector<T>& data)
+ static data::NDArrayPtr ConvertFromVector(const std::vector<T>& data)
{
- datanavigator::NDArrayNavigatorPtr ndArr(new datanavigator::NDArrayNavigator);
+ data::NDArrayPtr ndArr(new data::NDArray);
- ndArr->setDimensions({static_cast<int>(data.size()), sizeof(T)});
+ ndArr->setShape({static_cast<int>(data.size()), sizeof(T)});
ndArr->setData(sizeof(T) * data.size(), reinterpret_cast <const unsigned char* >(data.data()));
return ndArr;
diff --git a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.cpp b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.cpp
index faa6fadc1fbf5f3776ca73ee2363ff980713b41e..a15a5ad9243cd05ae875fb2dec9c76927fa20508 100644
--- a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.cpp
@@ -29,68 +29,68 @@
namespace armarx::aron::converter
{
- Eigen::Quaternion<float> AronEigenConverter::ConvertToQuaternionf(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Quaternion<float> AronEigenConverter::ConvertToQuaternionf(const data::NDArrayPtr& n)
{
return ConvertToQuaternion<float>(n);
}
- Eigen::Quaternion<double> AronEigenConverter::ConvertToQuaterniond(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Quaternion<double> AronEigenConverter::ConvertToQuaterniond(const data::NDArrayPtr& n)
{
return ConvertToQuaternion<double>(n);
}
- Eigen::Vector3f AronEigenConverter::ConvertToVector3f(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Vector3f AronEigenConverter::ConvertToVector3f(const data::NDArrayPtr& n)
{
return ConvertToVector<float, 3>(n);
}
- Eigen::Vector3d AronEigenConverter::ConvertToVector3d(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Vector3d AronEigenConverter::ConvertToVector3d(const data::NDArrayPtr& n)
{
return ConvertToVector<double, 3>(n);
}
- Eigen::Matrix4f AronEigenConverter::ConvertToMatrix4f(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Matrix4f AronEigenConverter::ConvertToMatrix4f(const data::NDArrayPtr& n)
{
return ConvertToMatrix<float, 4, 4>(n);
}
- Eigen::Matrix4d AronEigenConverter::ConvertToMatrix4d(const datanavigator::NDArrayNavigatorPtr& n)
+ Eigen::Matrix4d AronEigenConverter::ConvertToMatrix4d(const data::NDArrayPtr& n)
{
return ConvertToMatrix<double, 4, 4>(n);
}
- Eigen::Quaternion<float> AronEigenConverter::ConvertToQuaternionf(const datanavigator::NDArrayNavigator& n)
+ Eigen::Quaternion<float> AronEigenConverter::ConvertToQuaternionf(const data::NDArray& n)
{
return ConvertToQuaternion<float>(n);
}
- Eigen::Quaternion<double> AronEigenConverter::ConvertToQuaterniond(const datanavigator::NDArrayNavigator& n)
+ Eigen::Quaternion<double> AronEigenConverter::ConvertToQuaterniond(const data::NDArray& n)
{
return ConvertToQuaternion<double>(n);
}
- Eigen::Vector3f AronEigenConverter::ConvertToVector3f(const datanavigator::NDArrayNavigator& n)
+ Eigen::Vector3f AronEigenConverter::ConvertToVector3f(const data::NDArray& n)
{
return ConvertToVector<float, 3>(n);
}
- Eigen::Vector3d AronEigenConverter::ConvertToVector3d(const datanavigator::NDArrayNavigator& n)
+ Eigen::Vector3d AronEigenConverter::ConvertToVector3d(const data::NDArray& n)
{
return ConvertToVector<double, 3>(n);
}
- Eigen::Matrix4f AronEigenConverter::ConvertToMatrix4f(const datanavigator::NDArrayNavigator& n)
+ Eigen::Matrix4f AronEigenConverter::ConvertToMatrix4f(const data::NDArray& n)
{
return ConvertToMatrix<float, 4, 4>(n);
}
- Eigen::Matrix4d AronEigenConverter::ConvertToMatrix4d(const datanavigator::NDArrayNavigator& n)
+ Eigen::Matrix4d AronEigenConverter::ConvertToMatrix4d(const data::NDArray& n)
{
return ConvertToMatrix<double, 4, 4>(n);
}
void AronEigenConverter::checkDimensions(
- const datanavigator::NDArrayNavigator& nav, const std::vector<int>& expected,
+ const data::NDArray& nav, const std::vector<int>& expected,
const std::string& method, const std::string& caller)
{
- if (nav.getDimensions() != expected)
+ if (nav.getShape() != expected)
{
std::stringstream ss;
ss << "The size of an NDArray does not match.";
- ss << "\n Expected: \t" << datanavigator::NDArrayNavigator::DimensionsToString(expected);
- ss << "\n Got: \t" << datanavigator::NDArrayNavigator::DimensionsToString(nav.getDimensions());
+ ss << "\n Expected: \t" << data::NDArray::DimensionsToString(expected);
+ ss << "\n Got: \t" << data::NDArray::DimensionsToString(nav.getShape());
ss << "\n";
- throw error::AronException(caller, method, ss.str(), nav.getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, ss.str(), nav.getPath());
}
}
}
diff --git a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
index 810693b3af482ad0863e6dffd59adc0cf7ce68fe..56f6690c41d8eef765a0788312d8dff220d92695 100644
--- a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
@@ -33,7 +33,7 @@
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::aron::converter
@@ -45,32 +45,32 @@ namespace armarx::aron::converter
public:
// TODO: Add inplace methods
- static Eigen::Quaternion<float> ConvertToQuaternionf(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Quaternion<float> ConvertToQuaternionf(const datanavigator::NDArrayNavigator&);
- static Eigen::Quaternion<double> ConvertToQuaterniond(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Quaternion<double> ConvertToQuaterniond(const datanavigator::NDArrayNavigator&);
- static Eigen::Vector3f ConvertToVector3f(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Vector3f ConvertToVector3f(const datanavigator::NDArrayNavigator&);
- static Eigen::Vector3d ConvertToVector3d(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Vector3d ConvertToVector3d(const datanavigator::NDArrayNavigator&);
- static Eigen::Matrix4f ConvertToMatrix4f(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Matrix4f ConvertToMatrix4f(const datanavigator::NDArrayNavigator&);
- static Eigen::Matrix4d ConvertToMatrix4d(const datanavigator::NDArrayNavigatorPtr&);
- static Eigen::Matrix4d ConvertToMatrix4d(const datanavigator::NDArrayNavigator&);
+ static Eigen::Quaternion<float> ConvertToQuaternionf(const data::NDArrayPtr&);
+ static Eigen::Quaternion<float> ConvertToQuaternionf(const data::NDArray&);
+ static Eigen::Quaternion<double> ConvertToQuaterniond(const data::NDArrayPtr&);
+ static Eigen::Quaternion<double> ConvertToQuaterniond(const data::NDArray&);
+ static Eigen::Vector3f ConvertToVector3f(const data::NDArrayPtr&);
+ static Eigen::Vector3f ConvertToVector3f(const data::NDArray&);
+ static Eigen::Vector3d ConvertToVector3d(const data::NDArrayPtr&);
+ static Eigen::Vector3d ConvertToVector3d(const data::NDArray&);
+ static Eigen::Matrix4f ConvertToMatrix4f(const data::NDArrayPtr&);
+ static Eigen::Matrix4f ConvertToMatrix4f(const data::NDArray&);
+ static Eigen::Matrix4d ConvertToMatrix4d(const data::NDArrayPtr&);
+ static Eigen::Matrix4d ConvertToMatrix4d(const data::NDArray&);
template<typename T>
- static Eigen::Quaternion<T> ConvertToQuaternion(const datanavigator::NDArrayNavigatorPtr& nav)
+ static Eigen::Quaternion<T> ConvertToQuaternion(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
return ConvertToQuaternion<T>(*nav);
}
template<typename T>
- static Eigen::Quaternion<T> ConvertToQuaternion(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Quaternion<T> ConvertToQuaternion(const data::NDArray& nav)
{
checkDimensions(nav, {1, 4, sizeof(T)}, "ConvertToQuaternion");
- auto dims = nav.getDimensions();
+ auto dims = nav.getShape();
Eigen::Quaternion<T> ret;
memcpy(reinterpret_cast<unsigned char*>(ret.coeffs().data()), nav.getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
@@ -79,17 +79,17 @@ namespace armarx::aron::converter
template<typename T, int Size>
- static Eigen::Matrix<T, Size, 1> ConvertToVector(const datanavigator::NDArrayNavigatorPtr& nav)
+ static Eigen::Matrix<T, Size, 1> ConvertToVector(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
return ConvertToVector<T, Size>(*nav);
}
template<typename T, int Size>
- static Eigen::Matrix<T, Size, 1> ConvertToVector(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Matrix<T, Size, 1> ConvertToVector(const data::NDArray& nav)
{
checkDimensions(nav, {Size, 1, sizeof(T)}, "ConvertToVector");
- auto dims = nav.getDimensions();
+ auto dims = nav.getShape();
Eigen::Matrix<T, Size, 1> ret;
memcpy(reinterpret_cast<unsigned char*>(ret.data()), nav.getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
@@ -98,16 +98,16 @@ namespace armarx::aron::converter
template<typename T, int Rows, int Cols>
- static Eigen::Matrix<T, Rows, Cols> ConvertToMatrix(const datanavigator::NDArrayNavigatorPtr& nav)
+ static Eigen::Matrix<T, Rows, Cols> ConvertToMatrix(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
return ConvertToMatrix<T, Rows, Cols>(*nav);
}
template<typename T>
- static Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> ConvertToDynamicMatrix(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> ConvertToDynamicMatrix(const data::NDArray& nav)
{
- const auto dims = nav.getDimensions();
+ const auto dims = nav.getShape();
using MatrixT = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
@@ -117,7 +117,7 @@ namespace armarx::aron::converter
}
template<typename T, int Rows = Eigen::Dynamic, int Cols = Eigen::Dynamic>
- static Eigen::Matrix<T, Rows, Cols> ConvertToMatrix(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Matrix<T, Rows, Cols> ConvertToMatrix(const data::NDArray& nav)
{
if constexpr(Rows == Eigen::Dynamic and Cols == Eigen::Dynamic)
{
@@ -125,7 +125,7 @@ namespace armarx::aron::converter
}
checkDimensions(nav, {Rows, Cols, sizeof(T)}, "ConvertToMatrix");
- auto dims = nav.getDimensions();
+ auto dims = nav.getShape();
Eigen::Matrix<T, Rows, Cols> ret;
memcpy(reinterpret_cast<unsigned char*>(ret.data()), nav.getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
@@ -133,11 +133,11 @@ namespace armarx::aron::converter
}
template<typename T>
- static datanavigator::NDArrayNavigatorPtr ConvertFromMatrix(const Eigen::Matrix < T, Eigen::Dynamic, Eigen::Dynamic >& mat)
+ static data::NDArrayPtr ConvertFromMatrix(const Eigen::Matrix < T, Eigen::Dynamic, Eigen::Dynamic >& mat)
{
- datanavigator::NDArrayNavigatorPtr ndArr(new datanavigator::NDArrayNavigator);
+ data::NDArrayPtr ndArr(new data::NDArray);
- ndArr->setDimensions({static_cast<int>(mat.rows()), static_cast<int>(mat.cols())});
+ ndArr->setShape({static_cast<int>(mat.rows()), static_cast<int>(mat.cols())});
ndArr->setData(sizeof(T) * mat.size(), reinterpret_cast <const unsigned char* >(mat.data()));
return ndArr;
@@ -147,9 +147,9 @@ namespace armarx::aron::converter
// Eigen::Array
template<typename T>
- static Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> ConvertToDynamicArray(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic> ConvertToDynamicArray(const data::NDArray& nav)
{
- const auto dims = nav.getDimensions();
+ const auto dims = nav.getShape();
ARMARX_CHECK_EQUAL(dims.size(), 2);
using ArrayT = Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>;
@@ -159,7 +159,7 @@ namespace armarx::aron::converter
}
template<typename T, int Rows = Eigen::Dynamic, int Cols = Eigen::Dynamic>
- static Eigen::Matrix<T, Rows, Cols> ConvertToArray(const datanavigator::NDArrayNavigator& nav)
+ static Eigen::Matrix<T, Rows, Cols> ConvertToArray(const data::NDArray& nav)
{
if constexpr(Rows == Eigen::Dynamic and Cols == Eigen::Dynamic)
{
@@ -167,7 +167,7 @@ namespace armarx::aron::converter
}
checkDimensions(nav, {Rows, Cols, sizeof(T)}, "ConvertToMatrix");
- auto dims = nav.getDimensions();
+ auto dims = nav.getShape();
Eigen::Array<T, Rows, Cols> ret;
memcpy(reinterpret_cast<unsigned char*>(ret.data()), nav.getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
@@ -175,11 +175,11 @@ namespace armarx::aron::converter
}
template<typename T>
- static datanavigator::NDArrayNavigatorPtr ConvertFromArray(const Eigen::Array < T, Eigen::Dynamic, Eigen::Dynamic >& mat)
+ static data::NDArrayPtr ConvertFromArray(const Eigen::Array < T, Eigen::Dynamic, Eigen::Dynamic >& mat)
{
- datanavigator::NDArrayNavigatorPtr ndArr(new datanavigator::NDArrayNavigator);
+ data::NDArrayPtr ndArr(new data::NDArray);
- ndArr->setDimensions({static_cast<int>(mat.rows()), static_cast<int>(mat.cols())});
+ ndArr->setShape({static_cast<int>(mat.rows()), static_cast<int>(mat.cols())});
ndArr->setData(sizeof(T) * mat.size(), reinterpret_cast <const unsigned char* >(mat.data()));
return ndArr;
@@ -192,7 +192,7 @@ namespace armarx::aron::converter
/**
* @throw `error::AronException` If `nav`'s dimensions do not match `expected`.
*/
- static void checkDimensions(const datanavigator::NDArrayNavigator& nav, const std::vector<int>& expected,
+ static void checkDimensions(const data::NDArray& nav, const std::vector<int>& expected,
const std::string& method, const std::string& caller = "AronEigenConverter");
};
diff --git a/source/RobotAPI/libraries/aron/converter/ivt/CMakeLists.txt b/source/RobotAPI/libraries/aron/converter/ivt/CMakeLists.txt
index 376a1ae7bcbc17edf348c03d40b7c05602751e04..519394204c94c3a30d025633a13c613d782cc446 100644
--- a/source/RobotAPI/libraries/aron/converter/ivt/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/converter/ivt/CMakeLists.txt
@@ -10,6 +10,8 @@ set(LIBS
aron
ivt
ivtopencv
+
+ ${IVT_LIBRARIES}
)
set(LIB_FILES
diff --git a/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.cpp b/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.cpp
index 13b85f22684e0cc847b01147aebca4bbfdbdf84b..999359d6b79ef56bbe7352263556ad71316e7384 100644
--- a/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.cpp
@@ -29,19 +29,25 @@
namespace armarx::aron::converter
{
- std::shared_ptr<CByteImage> AronIVTConverter::ConvertToCByteImage(const datanavigator::NDArrayNavigatorPtr& nav)
+ std::shared_ptr<CByteImage> AronIVTConverter::ConvertToCByteImage(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
- if (nav->getDimensions().size() != 3) // +1 for bytes per pixel
+ if (nav->getShape().size() != 3) // +1 for bytes per pixel
{
- throw error::AronException("AronIVTConverter", "ConvertToCByteImage", "The size of an NDArray does not match.", nav->getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "The size of an NDArray does not match.", nav->getPath());
}
- auto dims = nav->getDimensions();
+ auto dims = nav->getShape();
auto ret = std::make_shared<CByteImage>();
ret->Set(dims[0], dims[1], static_cast<CByteImage::ImageType>(std::stoi(nav->getType())));
memcpy(reinterpret_cast<unsigned char*>(ret->pixels), nav->getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
return ret;
}
+
+ data::NDArrayPtr ConvertFromCByteImage(const std::shared_ptr<CByteImage>& img)
+ {
+ // TODO:
+ return nullptr;
+ }
}
diff --git a/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.h b/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.h
index 65752d37413a6cd916e01e75b69a92c7ab66ad4d..6d0c23d3b598c7dc55334c7181fa39885ee15ce4 100644
--- a/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/ivt/IVTConverter.h
@@ -30,7 +30,7 @@
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::aron::converter
@@ -39,6 +39,7 @@ namespace armarx::aron::converter
{
AronIVTConverter() = delete;
public:
- static std::shared_ptr<CByteImage> ConvertToCByteImage(const datanavigator::NDArrayNavigatorPtr&);
+ static std::shared_ptr<CByteImage> ConvertToCByteImage(const data::NDArrayPtr&);
+ static data::NDArrayPtr ConvertFromCByteImage(const std::shared_ptr<CByteImage>&);
};
}
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
index 3eb6f82327e13ed89629e5de76a41909a9f0f9e2..e984e760bc99c24c62c87c3d2217cf58d86eea89 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
@@ -1,42 +1,34 @@
#include "NLohmannJSONConverter.h"
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h>
-
-
namespace armarx::aron::converter
{
- nlohmann::json AronNlohmannJSONConverter::ConvertToNlohmannJSON(const datanavigator::DictNavigatorPtr& aron)
+ nlohmann::json AronNlohmannJSONConverter::ConvertToNlohmannJSON(const data::VariantPtr& aron)
{
nlohmann::json j;
ConvertToNlohmannJSON(aron, j);
return j;
}
- void AronNlohmannJSONConverter::ConvertToNlohmannJSON(const aron::datanavigator::DictNavigatorPtr& aron, nlohmann::json& j)
+ void AronNlohmannJSONConverter::ConvertToNlohmannJSON(const aron::data::VariantPtr& aron, nlohmann::json& j)
{
- aron::dataIO::writer::NlohmannJSONWriter dataWriter;
- aron::dataIO::Visitor::VisitAndSetup(dataWriter, aron);
- j = dataWriter.getResult();
+ aron::data::writer::NlohmannJSONWriter dataWriter;
+ j = aron::data::readAndWrite<Variant2NlohmannJSONConverterHelper>(aron);
}
- datanavigator::DictNavigatorPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSON(const nlohmann::json& j)
+ data::DictPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(const nlohmann::json& j)
{
- auto aron = std::make_shared<aron::datanavigator::DictNavigator>();
+ // TODO Switch case over json type and add other methods, e.g. for float, array, ...
+ // TODO add check if json is object_t
+ data::VariantPtr aron = std::make_shared<aron::data::Dict>();
ConvertFromNlohmannJSON(aron, j);
- return aron;
+ return data::Dict::DynamicCastAndCheck(aron);
}
- void AronNlohmannJSONConverter::ConvertFromNlohmannJSON(aron::datanavigator::DictNavigatorPtr& a, const nlohmann::json& e, const aron::typenavigator::NavigatorPtr& expectedStructure)
+ void AronNlohmannJSONConverter::ConvertFromNlohmannJSON(aron::data::VariantPtr& a, const nlohmann::json& e, const aron::type::VariantPtr& expectedStructure)
{
- aron::dataIO::reader::NlohmannJSONReader dataReader(e);
- aron::dataIO::writer::NavigatorWriter navWriter;
- aron::dataIO::Converter::ReadAndConvert(dataReader, navWriter, expectedStructure);
- a = aron::datanavigator::DictNavigator::DynamicCastAndCheck(navWriter.getResult());
+ aron::data::writer::NlohmannJSONWriter dataWriter;
+ a = aron::data::readAndWrite<NlohmannJSON2VariantConverterHelper>(e);
}
}
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
index 2e1a89c63511d9806951887a7461fa09dcb17da4..da90be6900e98802d7fcf05bc8a221dda410cc17 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
@@ -6,8 +6,14 @@
#include <numeric>
// Memory
-#include <RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+
+#include <RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.h>
+#include <RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.h>
+#include <RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>
+#include <RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>
+#include <RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h>
+#include <RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h>
// JSON
#include <SimoxUtility/json/json.hpp>
@@ -16,14 +22,24 @@ namespace armarx::aron::converter
{
class AronNlohmannJSONConverter
{
+ private:
+ struct Variant2NlohmannJSONConverterHelper :
+ public data::VariantConverter<data::writer::NlohmannJSONWriter, Variant2NlohmannJSONConverterHelper>
+ {
+ };
+
+ struct NlohmannJSON2VariantConverterHelper :
+ public data::NlohmannJSONConverter<data::writer::VariantWriter, NlohmannJSON2VariantConverterHelper>
+ {
+ };
public:
AronNlohmannJSONConverter() = delete;
- static nlohmann::json ConvertToNlohmannJSON(const datanavigator::DictNavigatorPtr&);
- static void ConvertToNlohmannJSON(const datanavigator::DictNavigatorPtr&, nlohmann::json&);
+ static nlohmann::json ConvertToNlohmannJSON(const data::VariantPtr&);
+ static void ConvertToNlohmannJSON(const data::VariantPtr&, nlohmann::json&);
- static datanavigator::DictNavigatorPtr ConvertFromNlohmannJSON(const nlohmann::json&);
- static void ConvertFromNlohmannJSON(datanavigator::DictNavigatorPtr&, const nlohmann::json&, const aron::typenavigator::NavigatorPtr& = nullptr);
+ static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json&);
+ static void ConvertFromNlohmannJSON(data::VariantPtr&, const nlohmann::json&, const aron::type::VariantPtr& = nullptr);
};
}
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
index 292b1a4c8a92af539e7a60361897bed73f2a1c6e..6208bd9b451862e74c1f137d70e61711b49299b2 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
@@ -29,18 +29,36 @@
namespace armarx::aron::converter
{
- cv::Mat AronOpenCVConverter::ConvertToMat(const datanavigator::NDArrayNavigatorPtr& nav)
+ cv::Mat AronOpenCVConverter::ConvertToMat(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
- if (nav->getDimensions().size() < 3)
+ if (nav->getShape().size() < 3)
{
- throw error::AronException("AronIVTConverter", "ConvertToCByteImage", "The size of an NDArray does not match.", nav->getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "The size of an NDArray does not match.", nav->getPath());
}
- auto dims = nav->getDimensions();
+ auto dims = nav->getShape();
cv::Mat ret(std::vector<int>({dims.begin(), std::prev(dims.end())}), std::stoi(nav->getType()));
- memcpy(reinterpret_cast<unsigned char*>(ret.data), nav->getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
+ auto size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
+ memcpy(reinterpret_cast<unsigned char*>(ret.data), nav->getData(), size);
+ return ret;
+ }
+
+ data::NDArrayPtr AronOpenCVConverter::ConvertFromMat(const cv::Mat& mat)
+ {
+ std::vector<int> dims;
+ for (int i = 0; i < mat.dims; ++i)
+ {
+ dims.push_back(mat.size[i]);
+ }
+ dims.push_back(mat.elemSize());
+
+ auto ret = std::make_shared<data::NDArray>();
+ ret->setShape(dims);
+ ret->setType(std::to_string(mat.type()));
+ ret->setData(std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()), reinterpret_cast<const unsigned char*>(mat.data));
+
return ret;
}
}
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
index 7b26277d8c6c61f2e4ef277bcb367c81931745f0..5223ce3da2a5ca471ebb1d8dcc54a70a347e02be 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
@@ -24,13 +24,13 @@
#include <memory>
#include <string>
-// Eigen
+// OpenCV
#include <opencv2/core/core.hpp>
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::aron::converter
@@ -40,7 +40,8 @@ namespace armarx::aron::converter
AronOpenCVConverter() = delete;
public:
- static cv::Mat ConvertToMat(const datanavigator::NDArrayNavigatorPtr&);
+ static cv::Mat ConvertToMat(const data::NDArrayPtr&);
+ static data::NDArrayPtr ConvertFromMat(const cv::Mat&);
};
}
diff --git a/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h b/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
index 9500dfd0273090216477003795164bffe608cf3c..1b7c12294bee8846fd37c3ff7cbb8727f80eca11 100644
--- a/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
@@ -32,7 +32,7 @@
// ArmarX
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h>
+#include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
namespace armarx::aron::converter
@@ -43,15 +43,15 @@ namespace armarx::aron::converter
public:
template<typename T>
- static pcl::PointCloud<T> ConvertToPointClout(const datanavigator::NDArrayNavigatorPtr& nav)
+ static pcl::PointCloud<T> ConvertToPointClout(const data::NDArrayPtr& nav)
{
ARMARX_CHECK_NOT_NULL(nav);
- if (nav->getDimensions().size() != 3) // +1 for bytes per pixel
+ if (nav->getShape().size() != 3) // +1 for bytes per pixel
{
throw error::AronException("AronIVTConverter", "ConvertToCByteImage", "The size of an NDArray does not match.", nav->getPath());
}
- auto dims = nav->getDimensions();
+ auto dims = nav->getShape();
pcl::PointCloud<T> ret(dims[0], dims[1]);
memcpy(reinterpret_cast<unsigned char*>(ret.points.data()), nav->getData(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
diff --git a/source/RobotAPI/libraries/aron/core/CMakeLists.txt b/source/RobotAPI/libraries/aron/core/CMakeLists.txt
index 6fb2477169dd25daf0c77564e49d2e737825ef7c..2bd9f9c9111fd23b53a5696841e76ff6572331f3 100644
--- a/source/RobotAPI/libraries/aron/core/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/core/CMakeLists.txt
@@ -11,268 +11,271 @@ set(LIBS
ArmarXCore
RobotAPIInterfaces
cppgen
- Simox::SimoxUtility
+ SimoxUtility
)
set(LIB_FILES
- Resolver.cpp
+ Descriptor.cpp
+ Exception.cpp
Path.cpp
- navigator/data/Navigator.cpp
- navigator/data/detail/NavigatorBase.cpp
- navigator/data/detail/PrimitiveNavigatorBase.cpp
- navigator/data/container/List.cpp
- navigator/data/container/Dict.cpp
- navigator/data/complex/NDArray.cpp
- navigator/data/primitive/Int.cpp
- navigator/data/primitive/Long.cpp
- navigator/data/primitive/Float.cpp
- navigator/data/primitive/Double.cpp
- navigator/data/primitive/String.cpp
- navigator/data/primitive/Bool.cpp
- navigator/data/NavigatorFactory.cpp
-
- navigator/type/Navigator.cpp
- navigator/type/detail/NavigatorBase.cpp
- navigator/type/detail/ContainerNavigatorBase.cpp
- navigator/type/detail/NDArrayNavigatorBase.cpp
- navigator/type/detail/PrimitiveNavigatorBase.cpp
- navigator/type/container/Object.cpp
- navigator/type/container/List.cpp
- navigator/type/container/Dict.cpp
- navigator/type/container/Tuple.cpp
- navigator/type/container/Pair.cpp
- navigator/type/ndarray/NDArray.cpp
- navigator/type/ndarray/EigenMatrix.cpp
- navigator/type/ndarray/EigenQuaternion.cpp
- navigator/type/ndarray/Image.cpp
- navigator/type/ndarray/IVTCByteImage.cpp
- navigator/type/ndarray/OpenCVMat.cpp
- navigator/type/ndarray/PCLPointCloud.cpp
- navigator/type/ndarray/Position.cpp
- navigator/type/ndarray/Pose.cpp
- navigator/type/ndarray/Orientation.cpp
- navigator/type/enum/IntEnum.cpp
- navigator/type/primitive/Int.cpp
- navigator/type/primitive/Long.cpp
- navigator/type/primitive/Float.cpp
- navigator/type/primitive/Double.cpp
- navigator/type/primitive/String.cpp
- navigator/type/primitive/Bool.cpp
- navigator/type/primitive/Time.cpp
- navigator/type/NavigatorFactory.cpp
-
- navigator/visitors/DataVisitor.cpp
- navigator/visitors/TypedDataVisitor.cpp
-
- io/dataIO/Writer.cpp
- io/dataIO/writer/navigator/NavigatorWriter.cpp
- io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
-
- io/dataIO/Reader.cpp
- io/dataIO/reader/navigator/NavigatorReader.cpp
- io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
-
- io/dataIO/visitor/Visitor.cpp
- io/dataIO/converter/Converter.cpp
-
- io/typeIO/Writer.cpp
- io/typeIO/writer/navigator/NavigatorWriter.cpp
- io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
-
- io/typeIO/Reader.cpp
- io/typeIO/reader/navigator/NavigatorReader.cpp
- io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
-
- io/typeIO/visitor/Visitor.cpp
- io/typeIO/converter/Converter.cpp
-
- codegenerator/codeWriter/cpp/Writer.cpp
- codegenerator/codeWriter/cpp/serializer/Serializer.cpp
- codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.cpp
- codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.cpp
- codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.cpp
- codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.cpp
- codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.cpp
- codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.cpp
- codegenerator/codeWriter/cpp/serializer/container/Dict.cpp
- codegenerator/codeWriter/cpp/serializer/container/List.cpp
- codegenerator/codeWriter/cpp/serializer/container/Object.cpp
- codegenerator/codeWriter/cpp/serializer/container/Tuple.cpp
- codegenerator/codeWriter/cpp/serializer/container/Pair.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/Image.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/Position.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.cpp
- codegenerator/codeWriter/cpp/serializer/ndarray/Pose.cpp
- codegenerator/codeWriter/cpp/serializer/enum/IntEnum.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Int.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Long.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Float.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Double.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/String.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Bool.cpp
- codegenerator/codeWriter/cpp/serializer/primitive/Time.cpp
- codegenerator/codeWriter/cpp/serializer/SerializerFactory.cpp
-
- codegenerator/typeReader/xml/Data.cpp
- codegenerator/typeReader/xml/ReaderFactory.cpp
- codegenerator/typeReader/xml/Reader.cpp
+ data/variant/Variant.cpp
+ data/variant/detail/SpecializedVariant.cpp
+ data/variant/detail/ContainerVariant.cpp
+ data/variant/detail/ComplexVariant.cpp
+ data/variant/detail/PrimitiveVariant.cpp
+ data/variant/container/List.cpp
+ data/variant/container/Dict.cpp
+ data/variant/complex/NDArray.cpp
+ data/variant/primitive/Int.cpp
+ data/variant/primitive/Long.cpp
+ data/variant/primitive/Float.cpp
+ data/variant/primitive/Double.cpp
+ data/variant/primitive/String.cpp
+ data/variant/primitive/Bool.cpp
+ data/variant/Factory.cpp
+
+ type/variant/Variant.cpp
+ type/variant/detail/SpecializedVariant.cpp
+ type/variant/detail/ContainerVariant.cpp
+ type/variant/detail/NDArrayVariant.cpp
+ type/variant/detail/EnumVariant.cpp
+ type/variant/detail/PrimitiveVariant.cpp
+ type/variant/container/Object.cpp
+ type/variant/container/List.cpp
+ type/variant/container/Dict.cpp
+ type/variant/container/Tuple.cpp
+ type/variant/container/Pair.cpp
+ type/variant/ndarray/NDArray.cpp
+ type/variant/ndarray/Matrix.cpp
+ type/variant/ndarray/Quaternion.cpp
+ type/variant/ndarray/Image.cpp
+ type/variant/ndarray/PointCloud.cpp
+ type/variant/ndarray/Position.cpp
+ type/variant/ndarray/Pose.cpp
+ type/variant/ndarray/Orientation.cpp
+ type/variant/enum/IntEnum.cpp
+ type/variant/primitive/Int.cpp
+ type/variant/primitive/Long.cpp
+ type/variant/primitive/Float.cpp
+ type/variant/primitive/Double.cpp
+ type/variant/primitive/String.cpp
+ type/variant/primitive/Bool.cpp
+ type/variant/primitive/Time.cpp
+ type/variant/Factory.cpp
+
+ data/rw/Writer.cpp
+ data/rw/writer/variant/VariantWriter.cpp
+ data/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
+
+ data/rw/Reader.cpp
+ data/rw/reader/variant/VariantReader.cpp
+ data/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
+
+ type/rw/Writer.cpp
+ type/rw/writer/variant/VariantWriter.cpp
+ type/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
+
+ type/rw/Reader.cpp
+ type/rw/reader/variant/VariantReader.cpp
+ type/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
+
+ data/visitor/Visitor.cpp
+ data/visitor/RecursiveVisitor.cpp
+ data/visitor/variant/VariantVisitor.cpp
+ data/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
+ type/visitor/Visitor.cpp
+ type/visitor/RecursiveVisitor.cpp
+ type/visitor/variant/VariantVisitor.cpp
+ type/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
+
+ data/converter/Converter.cpp
+ data/converter/variant/VariantConverter.cpp
+ data/converter/nlohmannJSON/NlohmannJSONConverter.cpp
+
+ typereader/xml/Data.cpp
+ typereader/xml/Factory.cpp
+ typereader/xml/Reader.cpp
+
+ codegenerator/codewriter/cpp/Writer.cpp
+ codegenerator/codewriter/cpp/generator/Generator.cpp
+ codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.cpp
+ codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.cpp
+ codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.cpp
+ codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.cpp
+ codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.cpp
+ codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp
+ codegenerator/codewriter/cpp/generator/container/Dict.cpp
+ codegenerator/codewriter/cpp/generator/container/List.cpp
+ codegenerator/codewriter/cpp/generator/container/Object.cpp
+ codegenerator/codewriter/cpp/generator/container/Tuple.cpp
+ codegenerator/codewriter/cpp/generator/container/Pair.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/NDArray.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Matrix.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Image.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/PointCloud.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Position.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Orientation.cpp
+ codegenerator/codewriter/cpp/generator/ndarray/Pose.cpp
+ codegenerator/codewriter/cpp/generator/enum/IntEnum.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Int.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Long.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Float.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Double.cpp
+ codegenerator/codewriter/cpp/generator/primitive/String.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Bool.cpp
+ codegenerator/codewriter/cpp/generator/primitive/Time.cpp
+ codegenerator/codewriter/cpp/generator/Factory.cpp
)
set(LIB_HEADERS
- Debug.h
- Config.h
- Concepts.h
Descriptor.h
- Resolver.h
- Randomizer.h
Exception.h
- Factory.h
Path.h
- navigator/Navigator.h
- navigator/NavigatorFactory.h
-
- navigator/data/Navigator.h
- navigator/data/detail/NavigatorBase.h
- navigator/data/detail/PrimitiveNavigatorBase.h
- navigator/data/container/List.h
- navigator/data/container/Dict.h
- navigator/data/complex/NDArray.h
- navigator/data/primitive/Int.h
- navigator/data/primitive/Long.h
- navigator/data/primitive/Float.h
- navigator/data/primitive/Double.h
- navigator/data/primitive/String.h
- navigator/data/primitive/Bool.h
- navigator/data/AllNavigators.h
- navigator/data/NavigatorFactory.h
- navigator/data/forward_declarations.h
-
- navigator/type/Navigator.h
- navigator/type/detail/NavigatorBase.h
- navigator/type/detail/ContainerNavigatorBase.h
- navigator/type/detail/NDArrayNavigatorBase.h
- navigator/type/detail/PrimitiveNavigatorBase.h
- navigator/type/container/Object.h
- navigator/type/container/List.h
- navigator/type/container/Dict.h
- navigator/type/container/Tuple.h
- navigator/type/container/Pair.h
- navigator/type/ndarray/NDArray.h
- navigator/type/ndarray/EigenMatrix.h
- navigator/type/ndarray/EigenQuaternion.h
- navigator/type/ndarray/IVTCByteImage.h
- navigator/type/ndarray/Image.h
- navigator/type/ndarray/OpenCVMat.h
- navigator/type/ndarray/PCLPointCloud.h
- navigator/type/ndarray/Position.h
- navigator/type/ndarray/Pose.h
- navigator/type/ndarray/Orientation.h
- navigator/type/enum/IntEnum.h
- navigator/type/primitive/Int.h
- navigator/type/primitive/Long.h
- navigator/type/primitive/Float.h
- navigator/type/primitive/Double.h
- navigator/type/primitive/String.h
- navigator/type/primitive/Bool.h
- navigator/type/primitive/Time.h
- navigator/type/AllNavigators.h
- navigator/type/NavigatorFactory.h
- navigator/type/forward_declarations.h
-
- navigator/visitors/DataVisitor.h
- navigator/visitors/TypedDataVisitor.h
-
- io/Data.h
-
- io/dataIO/Writer.h
- io/dataIO/writer/WriterToken.h
- io/dataIO/writer/navigator/NavigatorWriterToken.h
- io/dataIO/writer/navigator/NavigatorWriter.h
- io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h
- io/dataIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
-
- io/dataIO/Reader.h
- io/dataIO/reader/ReaderToken.h
- io/dataIO/reader/navigator/NavigatorReaderToken.h
- io/dataIO/reader/navigator/NavigatorReader.h
- io/dataIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
- io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h
-
- io/dataIO/visitor/Visitor.h
- io/dataIO/converter/Converter.h
-
- io/typeIO/Writer.h
- io/typeIO/writer/WriterToken.h
- io/typeIO/writer/navigator/NavigatorWriterToken.h
- io/typeIO/writer/navigator/NavigatorWriter.h
- io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h
- io/typeIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
-
- io/typeIO/Reader.h
- io/typeIO/reader/ReaderToken.h
- io/typeIO/reader/navigator/NavigatorReader.h
- io/typeIO/reader/navigator/NavigatorReaderToken.h
- io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.h
- io/typeIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
-
- io/typeIO/visitor/Visitor.h
- io/typeIO/converter/Converter.h
-
- codegenerator/WriterInfo.h
- codegenerator/ReaderInfo.h
- codegenerator/GenerateTypeInfo.h
- codegenerator/GenerateIntEnumInfo.h
-
- codegenerator/codeWriter/CodeWriter.h
- codegenerator/codeWriter/SerializerFactory.h
-
- codegenerator/codeWriter/cpp/AronCppClass.h
- codegenerator/codeWriter/cpp/Writer.h
- codegenerator/codeWriter/cpp/serializer/Serializer.h
- codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h
- codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h
- codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h
- codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h
- codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.h
- codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.h
- codegenerator/codeWriter/cpp/serializer/container/Dict.h
- codegenerator/codeWriter/cpp/serializer/container/List.h
- codegenerator/codeWriter/cpp/serializer/container/Object.h
- codegenerator/codeWriter/cpp/serializer/container/Tuple.h
- codegenerator/codeWriter/cpp/serializer/container/Pair.h
- codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.h
- codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.h
- codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.h
- codegenerator/codeWriter/cpp/serializer/ndarray/Image.h
- codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.h
- codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.h
- codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.h
- codegenerator/codeWriter/cpp/serializer/ndarray/Position.h
- codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.h
- codegenerator/codeWriter/cpp/serializer/ndarray/Pose.h
- codegenerator/codeWriter/cpp/serializer/enum/IntEnum.h
- codegenerator/codeWriter/cpp/serializer/primitive/Int.h
- codegenerator/codeWriter/cpp/serializer/primitive/Long.h
- codegenerator/codeWriter/cpp/serializer/primitive/Float.h
- codegenerator/codeWriter/cpp/serializer/primitive/Double.h
- codegenerator/codeWriter/cpp/serializer/primitive/String.h
- codegenerator/codeWriter/cpp/serializer/primitive/Bool.h
- codegenerator/codeWriter/cpp/serializer/primitive/Time.h
- codegenerator/codeWriter/cpp/serializer/AllSerializers.h
- codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
-
- codegenerator/typeReader/Reader.h
- codegenerator/typeReader/xml/Data.h
- codegenerator/typeReader/xml/ReaderFactory.h
- codegenerator/typeReader/xml/Reader.h
+ data/variant/Variant.h
+ data/variant/detail/SpecializedVariant.h
+ data/variant/detail/ContainerVariant.h
+ data/variant/detail/ComplexVariant.h
+ data/variant/detail/PrimitiveVariant.h
+ data/variant/container/List.h
+ data/variant/container/Dict.h
+ data/variant/container/All.h
+ data/variant/complex/NDArray.h
+ data/variant/complex/All.h
+ data/variant/primitive/Int.h
+ data/variant/primitive/Long.h
+ data/variant/primitive/Float.h
+ data/variant/primitive/Double.h
+ data/variant/primitive/String.h
+ data/variant/primitive/Bool.h
+ data/variant/primitive/All.h
+
+ data/variant/All.h
+ data/variant/Factory.h
+ data/variant/forward_declarations.h
+
+ type/variant/Variant.h
+ type/variant/detail/SpecializedVariant.h
+ type/variant/detail/ContainerVariant.h
+ type/variant/detail/NDArrayVariant.h
+ type/variant/detail/EnumVariant.h
+ type/variant/detail/PrimitiveVariant.h
+ type/variant/container/Object.h
+ type/variant/container/List.h
+ type/variant/container/Dict.h
+ type/variant/container/Tuple.h
+ type/variant/container/Pair.h
+ type/variant/container/All.h
+ type/variant/ndarray/NDArray.h
+ type/variant/ndarray/Matrix.h
+ type/variant/ndarray/Quaternion.h
+ type/variant/ndarray/Image.h
+ type/variant/ndarray/PointCloud.h
+ type/variant/ndarray/Position.h
+ type/variant/ndarray/Pose.h
+ type/variant/ndarray/Orientation.h
+ type/variant/ndarray/All.h
+ type/variant/enum/IntEnum.h
+ type/variant/enum/All.h
+ type/variant/primitive/Int.h
+ type/variant/primitive/Long.h
+ type/variant/primitive/Float.h
+ type/variant/primitive/Double.h
+ type/variant/primitive/String.h
+ type/variant/primitive/Bool.h
+ type/variant/primitive/Time.h
+ type/variant/primitive/All.h
+ type/variant/All.h
+ type/variant/Factory.h
+ type/variant/forward_declarations.h
+
+ data/rw/json/Data.h
+
+ data/rw/Writer.h
+ data/rw/writer/variant/VariantWriter.h
+ data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
+
+ data/rw/Reader.h
+ data/rw/reader/variant/VariantReader.h
+ data/rw/reader/nlohmannJSON/NlohmannJSONReader.h
+
+ type/rw/json/Data.h
+
+ type/rw/Writer.h
+ type/rw/writer/variant/VariantWriter.h
+ type/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
+
+ type/rw/Reader.h
+ type/rw/reader/variant/VariantReader.h
+ type/rw/reader/nlohmannJSON/NlohmannJSONReader.h
+
+ data/visitor/Visitor.h
+ data/visitor/RecursiveVisitor.h
+ data/visitor/variant/VariantVisitor.h
+ data/visitor/nlohmannJSON/NlohmannJSONVisitor.h
+ type/visitor/Visitor.h
+ type/visitor/RecursiveVisitor.h
+ type/visitor/variant/VariantVisitor.h
+ type/visitor/nlohmannJSON/NlohmannJSONVisitor.h
+
+ data/converter/Converter.h
+ data/converter/variant/VariantConverter.h
+ data/converter/nlohmannJSON/NlohmannJSONConverter.h
+
+ typereader/helper/GenerateInfo.h
+ typereader/helper/GenerateTypeInfo.h
+ typereader/helper/GenerateIntEnumInfo.h
+
+ typereader/Reader.h
+ typereader/xml/Data.h
+ typereader/xml/Factory.h
+ typereader/xml/Reader.h
+
+ codegenerator/helper/WriterInfo.h
+ codegenerator/helper/ReaderInfo.h
+
+ codegenerator/codewriter/CodeWriter.h
+ codegenerator/codewriter/Factory.h
+
+ codegenerator/codewriter/cpp/AronCppClass.h
+ codegenerator/codewriter/cpp/Writer.h
+ codegenerator/codewriter/cpp/generator/Generator.h
+ codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h
+ codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h
+ codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h
+ codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h
+ codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h
+ codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h
+ codegenerator/codewriter/cpp/generator/toplevel/All.h
+ codegenerator/codewriter/cpp/generator/container/Dict.h
+ codegenerator/codewriter/cpp/generator/container/List.h
+ codegenerator/codewriter/cpp/generator/container/Object.h
+ codegenerator/codewriter/cpp/generator/container/Tuple.h
+ codegenerator/codewriter/cpp/generator/container/Pair.h
+ codegenerator/codewriter/cpp/generator/container/All.h
+ codegenerator/codewriter/cpp/generator/ndarray/NDArray.h
+ codegenerator/codewriter/cpp/generator/ndarray/Matrix.h
+ codegenerator/codewriter/cpp/generator/ndarray/Quaternion.h
+ codegenerator/codewriter/cpp/generator/ndarray/Image.h
+ codegenerator/codewriter/cpp/generator/ndarray/PointCloud.h
+ codegenerator/codewriter/cpp/generator/ndarray/Position.h
+ codegenerator/codewriter/cpp/generator/ndarray/Orientation.h
+ codegenerator/codewriter/cpp/generator/ndarray/Pose.h
+ codegenerator/codewriter/cpp/generator/ndarray/All.h
+ codegenerator/codewriter/cpp/generator/enum/IntEnum.h
+ codegenerator/codewriter/cpp/generator/enum/All.h
+ codegenerator/codewriter/cpp/generator/primitive/Int.h
+ codegenerator/codewriter/cpp/generator/primitive/Long.h
+ codegenerator/codewriter/cpp/generator/primitive/Float.h
+ codegenerator/codewriter/cpp/generator/primitive/Double.h
+ codegenerator/codewriter/cpp/generator/primitive/String.h
+ codegenerator/codewriter/cpp/generator/primitive/Bool.h
+ codegenerator/codewriter/cpp/generator/primitive/Time.h
+ codegenerator/codewriter/cpp/generator/primitive/All.h
+ codegenerator/codewriter/cpp/generator/All.h
+ codegenerator/codewriter/cpp/generator/Factory.h
)
diff --git a/source/RobotAPI/libraries/aron/core/Concepts.h b/source/RobotAPI/libraries/aron/core/Concepts.h
deleted file mode 100644
index 91c9d0931152d15491adf6e7efb8462cc5bcfe57..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Concepts.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-
-namespace armarx::aron
-{
- template<class T>
- static constexpr bool isPrimitive =
- std::is_same_v<T, int > ||
- std::is_same_v<T, long > ||
- std::is_same_v<T, float > ||
- std::is_same_v<T, double > ||
- std::is_same_v<T, bool > ||
- std::is_same_v<T, std::string>;
-
-
- // TODO: make nice
- /* // General Concepts
- template <typename CppType>
- concept IsAronPrimitiveCppType = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<CppType, lowerType>::value)
-
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
- ;
-
- template <typename AronData, typename CppType>
- concept AreAronPrimitiveDependent = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronData, Aron##upperType>::value && std::is_same<CppType, lowerType>::value)
-
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
- ;
-
- template <typename AronData>
- concept IsAronData = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronData, Aron##upperType>::value)
-
- HANDLE_ALL_ARON_DATA
- #undef RUN_ARON_MACRO
- ;
-
- template <typename AronAbstractTypeType>
- concept IsAronAbstractType = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronAbstractTypeType, Aron##upperType##Type>::value)
-
- HANDLE_ALL_ARON_TYPES
- #undef RUN_ARON_MACRO
- ;
-
- template <typename AronAbstractTypeType, typename AronData, typename CppType>
- concept AreAronAbstractTypeAndPrimitiveDependent = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronAbstractTypeType, Aron##upperType##Type>::value && std::is_same<AronData, Aron##upperType>::value && std::is_same<CppType, lowerType>::value)
-
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
- ;
-
-
-
- // Compound
- template <typename Aron>
- concept isAron = IsAronData<Aron> || IsAronAbstractType<Aron>;
-
-
-
-
-
- // Navigator Concepts
- namespace data
- {
- class Navigator;
-
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##Navigator;
-
- HANDLE_CONTAINER_DATA
- #undef RUN_ARON_MACRO
-
- template<typename AronDataType, typename CppType> requires AreAronPrimitiveDependent<AronDataType, CppType>
- class AronPrimitiveDataNavigator;
-
- template <typename Navigator>
- concept IsNavigator = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<Navigator, upperType##Navigator>::value)
-
- HANDLE_CONTAINER_DATA
- #undef RUN_ARON_MACRO
-
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<Navigator, AronPrimitiveDataNavigator<Aron##upperType, lowerType>>::value)
-
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
- ;
- }
-
-
-
-
-
- // AronAbstractTypeNavigator Concepts
- namespace types
- {
- class AronAbstractTypeNavigator;
-
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##Navigator;
-
- HANDLE_CONTAINER_TYPES
- #undef RUN_ARON_MACRO
-
- template<typename AronAbstractTypeType, typename AronDataType, typename CppType> requires AreAronAbstractTypeAndPrimitiveDependent<AronAbstractTypeType, AronDataType, CppType>
- class AronPrimitiveTypeNavigator;
-
- template <typename AronAbstractTypeNavigator>
- concept IsAronAbstractTypeNavigator = false
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronAbstractTypeNavigator, upperType##Navigator>::value)
-
- HANDLE_CONTAINER_TYPES
- #undef RUN_ARON_MACRO
-
- #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- || (std::is_same<AronAbstractTypeNavigator, AronPrimitiveTypeNavigator<Aron##upperType##Type, Aron##upperType, lowerType>>::value)
-
- HANDLE_PRIMITIVE_TYPES
- #undef RUN_ARON_MACRO
- ;
- }*/
-}
diff --git a/source/RobotAPI/libraries/aron/core/Config.h b/source/RobotAPI/libraries/aron/core/Config.h
deleted file mode 100644
index a8c7d0fb044619530635da4c3cb709f579fe7757..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Config.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-/**
- * This file contains the general structure of all accepted AronTypes.
- *
- * In general we distinguish we distinguish between container(complex) and primitive types.
- * Complex types include Objects, Lists, Dicts, Pairs and Blobs.
- * Pimitive types on the other hand include int, long, float, double, string and bools.
- *
- * A primitive always has only one member containing the value of the aron. A container type can have multiple members.
- *
- * Note that every AronData must have a corresponding AronAbstractType (both declared in aron.ice).
- * The AronData is a copy of cpp values while the AronAbstractType describes the type structure.
- *
- * In the following we descripe the types in more detail:
- * AronData:
- * |
- * |->Container:
- * | |
- * | |->AronObject:
- * | | This container represents cpp classes. It contains a std::map mapping from a membername (std::string) to AronData.
- * | | It is a recursive structure that again can contain other complex or primitive types.
- * | |
- * | |->AronList:
- * This container represents a std::vector<T> where T can be any datatype convertable to Aron.
- * TODO: complete doc
- */
-
-
-#include <string>
-
-namespace armarx
-{
- namespace aron
- {
- // This simplifies code generation.
- // It may be removed in favor of another solution in the future.
- using string = std::string;
- }
-}
-
-
-/************************************
- * TYPES ****************************
- ***********************************/
-
-// All containertypes go here
-#define HANDLE_CONTAINER_TYPES \
- RUN_ARON_MACRO(Object, object, OBJECT) \
- RUN_ARON_MACRO(List, list, LIST) \
- RUN_ARON_MACRO(Dict, dict, DICT) \
- RUN_ARON_MACRO(Pair, pair, PAIR) \
- RUN_ARON_MACRO(Tuple, tuple, TUPLE)
-
-#define HANDLE_DICT_SERIALIZER_TYPES \
- RUN_ARON_MACRO(Object, object, OBJECT) \
- RUN_ARON_MACRO(Dict, dict, DICT)
-
-#define HANDLE_LIST_SERIALIZER_TYPES \
- RUN_ARON_MACRO(List, list, LIST) \
- RUN_ARON_MACRO(Tuple, tuple, TUPLE) \
- RUN_ARON_MACRO(Pair, pair, PAIR)
-
-// All complex types go here
-#define HANDLE_NDARRAY_TYPES \
- RUN_ARON_MACRO(NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(EigenMatrix, eigenmatrix, EIGEN_MATRIX) \
- RUN_ARON_MACRO(EigenQuaternion, eigenquaternion, EIGEN_QUATERNION) \
- RUN_ARON_MACRO(Image, image, IMAGE) \
- RUN_ARON_MACRO(IVTCByteImage, ivtcbyteimage, IVT_CBYTE_IMAGE) \
- RUN_ARON_MACRO(OpenCVMat, opencvmat, OPENCV_MAT) \
- RUN_ARON_MACRO(PCLPointCloud, pclpointcloud, PCL_POINTCLOUD) \
- RUN_ARON_MACRO(Position, position, POSITION) \
- RUN_ARON_MACRO(Orientation, orientation, ORIENTATION) \
- RUN_ARON_MACRO(Pose, pose, POSE)
-
-// All enum types (they differ from primitive types since they have a list of accepted values and names)
-// TODO: Think about extending enums to StringEnums, FloatEnumns etc.
-#define HANDLE_ENUM_TYPES \
- RUN_ARON_MACRO(IntEnum, intenum, INT_ENUM)
-
-// All primitive types
-#define HANDLE_PRIMITIVE_TYPES \
- RUN_ARON_MACRO(Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE) \
- RUN_ARON_MACRO(String, string, STRING) \
- RUN_ARON_MACRO(Bool, bool, BOOL) \
- RUN_ARON_MACRO(Time, time, TIME)
-
-// All combined
-#define HANDLE_ALL_ARON_TYPES \
- HANDLE_CONTAINER_TYPES \
- HANDLE_NDARRAY_TYPES \
- HANDLE_ENUM_TYPES \
- HANDLE_PRIMITIVE_TYPES
-
-/************************************
- * DATA *****************************
- ***********************************/
-
-// All containerdata go here
-#define HANDLE_CONTAINER_DATA \
- RUN_ARON_MACRO(List, list, LIST) \
- RUN_ARON_MACRO(Dict, dict, DICT)
-
-#define HANDLE_COMPLEX_DATA \
- RUN_ARON_MACRO(NDArray, ndarray, NDARRAY)
-
-// the lowercase name must be euqal to the cpp name
-#define HANDLE_PRIMITIVE_DATA \
- RUN_ARON_MACRO(Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE) \
- RUN_ARON_MACRO(String, string, STRING) \
- RUN_ARON_MACRO(Bool, bool, BOOL)
-
-// if you only need the "real" primitives
-#define HANDLE_PRIMITIVE_DATA_EXCEPT_STRING \
- RUN_ARON_MACRO(Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE) \
- RUN_ARON_MACRO(Bool, bool, BOOL)
-
-// All three combined
-#define HANDLE_ALL_ARON_DATA \
- HANDLE_CONTAINER_DATA \
- HANDLE_COMPLEX_DATA \
- HANDLE_PRIMITIVE_DATA
-
-/************************************
- * What type corresponds to which data
- * (t,t,T,d,d,D) => t in Type, d in Data
- ***********************************/
-#define HANDLE_CONTAINER_CORRESPONDING \
- RUN_ARON_MACRO(List, list, LIST, List, list, LIST) \
- RUN_ARON_MACRO(Pair, pair, PAIR, List, list, LIST) \
- RUN_ARON_MACRO(Tuple, tuple, TUPLE, List, list, LIST) \
- RUN_ARON_MACRO(Object, object, OBJECT, Dict, dict, DICT) \
- RUN_ARON_MACRO(Dict, dict, DICT, Dict, dict, DICT)
-
-#define HANDLE_COMPLEX_CORRESPONDING \
- RUN_ARON_MACRO(NDArray, ndarray, NDARRAY, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(EigenMatrix, eigenmatrix, EIGEN_MATRIX, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(EigenQuaternion, eigenmatrix, EIGEN_MATRIX, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(Image, image, IMAGE, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(IVTCByteImage, ivtcbyteimage, IVT_CBYTE_IMAGE, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(OpenCVMat, opencvmat, OPENCV_MAT, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(PCLPointCloud, pclpointcloud, PCL_POINTCLOUD, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(Position, position, POSITION, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(Orientation, orientation, ORIENTATION, NDArray, ndarray, NDARRAY) \
- RUN_ARON_MACRO(Pose, pose, POSE, NDArray, ndarray, NDARRAY)
-
-#define HANDLE_ENUM_CORRESPONDING \
- RUN_ARON_MACRO(IntEnum, intenum, INT_ENUM, Int, int, INT)
-
-#define HANDLE_PRIMITIVE_CORRESPONDING \
- RUN_ARON_MACRO(Int, int, INT, Int, int, INT) \
- RUN_ARON_MACRO(Long, long, LONG, Long, long, LONG) \
- RUN_ARON_MACRO(Float, float, FLOAT, Float, float, FLOAT) \
- RUN_ARON_MACRO(Double, double, DOUBLE, Double, double, DOUBLE) \
- RUN_ARON_MACRO(String, string, STRING, String, string, STRING) \
- RUN_ARON_MACRO(Bool, bool, BOOL, Bool, bool, BOOL) \
- RUN_ARON_MACRO(Time, time, TIME, Long, long, LONG)
-
-#define HANDLE_ALL_CORRESPONDING \
- HANDLE_CONTAINER_CORRESPONDING \
- HANDLE_COMPLEX_CORRESPONDING \
- HANDLE_ENUM_CORRESPONDING \
- HANDLE_PRIMITIVE_CORRESPONDING
-
-/************************************
- * Related data types ***************
- * (which on can be converted into what)
- * automatically symmetric but not transitive
- ***********************************/
-#define HANDLE_ARON_PRIMITIVE_DATA_RELATED \
- RUN_ARON_MACRO(Int, int, INT, Long, long, LONG) \
- RUN_ARON_MACRO(Int, int, INT, Float, float, FLOAT) \
- RUN_ARON_MACRO(Int, int, INT, Double, double, DOUBLE) \
- RUN_ARON_MACRO(Long, long, LONG, Float, float, FLOAT) \
- RUN_ARON_MACRO(Long, long, LONG, Double, double, DOUBLE) \
- RUN_ARON_MACRO(Float, float, FLOAT, Double, double, DOUBLE)
diff --git a/source/RobotAPI/libraries/aron/core/Debug.h b/source/RobotAPI/libraries/aron/core/Debug.h
deleted file mode 100644
index 672b47deeb901506af09f0b2cd49a998ede7f95c..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Debug.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-#include <RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h>
-
-#include <RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h>
-
-namespace armarx::aron
-{
- class Debug
- {
- public:
- Debug() = delete;
-
- static std::string AronDataPtrToString(const data::AronDataPtr& data)
- {
- if (!data)
- {
- return "";
- }
-
- dataIO::writer::NlohmannJSONWriter w;
- dataIO::Visitor::VisitAndSetup(w, data);
- return w.getResult().dump(2);
- }
-
- static std::string NavigatorPtrToString(const datanavigator::NavigatorPtr& data)
- {
- if (!data)
- {
- return "";
- }
-
- dataIO::writer::NlohmannJSONWriter w;
- dataIO::Visitor::VisitAndSetup(w, data);
- return w.getResult().dump(2);
- }
-
- static std::string AronTypePtrToString(const type::AronTypePtr& data)
- {
- typeIO::writer::NlohmannJSONWriter w;
- typeIO::Visitor::VisitAndSetup(w, data);
- return w.getResult().dump(2);
- }
-
- static std::string NavigatorPtrToString(const typenavigator::NavigatorPtr& data)
- {
- typeIO::writer::NlohmannJSONWriter w;
- typeIO::Visitor::VisitAndSetup(w, data);
- return w.getResult().dump(2);
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/Descriptor.cpp b/source/RobotAPI/libraries/aron/core/Descriptor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87464568d22f9e3f433c5b32e85e9c88ae4aa812
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/Descriptor.cpp
@@ -0,0 +1,24 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Descriptor.h"
diff --git a/source/RobotAPI/libraries/aron/core/Descriptor.h b/source/RobotAPI/libraries/aron/core/Descriptor.h
index bcf2d0c3173dfc12493d0e5dac0155da81217c57..f6a8dfdfcb0eee15c3daf650462bc743d297fb12 100644
--- a/source/RobotAPI/libraries/aron/core/Descriptor.h
+++ b/source/RobotAPI/libraries/aron/core/Descriptor.h
@@ -30,13 +30,84 @@
#include <map>
#include <string>
+// Simox
+#include <SimoxUtility/algorithm/string.h>
+
// ArmarX
#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
+
+
+/**
+ * This file contains basic enums to distinguish aron::data and aron::types and utility functions to generate maps converting the neum to strings or vice versa.
+ * Further, this file contains a conversion map from ice_ids to descriptors.
+ *
+ * Every data- or type-object has a descriptor, containing the correct enum for this object. All aron-variants must be either:
+ * DATA:
+ * - Dict
+ * - List
+ * - NDArray
+ * - Int
+ * - Long
+ * - Float
+ * - Double
+ * - String
+ * - Bool
+ *
+ * TYPE:
+ * - Object
+ * - Dict
+ * - List
+ * - Pair
+ * - Tuple
+ * - NDArray
+ * - Matrix
+ * - Orientation
+ * - Position
+ * - Pose
+ * - Quaternion
+ * - Image
+ * - Pointcloud
+ * - Int Enum
+ * - Int
+ * - Long
+ * - Float
+ * - Double
+ * - String
+ * - Bool
+ * - Time
+ *
+ * A variant should never have eUnknown as its internal type (The enums are const and only set on construction).
+ * If you want to execute a specific function for a specific variant, please refer to the visitor implementation.
+ */
+namespace armarx::aron::conversion::util
+{
+ template <class T1, class T2>
+ std::map<T2, T1> InvertMap(const std::map<T1, T2>& m)
+ {
+ std::map<T2, T1> ret;
+ for (const auto &[key, val] : m)
+ {
+ ret.emplace(val, key);
+ }
+ return ret;
+ }
+
+ template <class T>
+ std::map<T, std::string> InvertMap(const std::map<std::string, T>& m)
+ {
+ return InvertMap<std::string, T>(m);
+ }
+
+ template <class T>
+ std::map<std::string, T> InvertMap(const std::map<T, std::string>& m)
+ {
+ return InvertMap<T, std::string>(m);
+ }
+}
namespace armarx::aron::type
{
- const std::vector<type::Maybe> ALL_MAYBE_TYPES =
+ const std::vector<type::Maybe> AllMaybeTypes =
{
type::Maybe::eNone,
type::Maybe::eOptional,
@@ -47,77 +118,128 @@ namespace armarx::aron::type
enum class Descriptor
{
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- e##upperType,
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
+ eList,
+ eObject,
+ eTuple,
+ ePair,
+ eDict,
+ eNDArray,
+ eMatrix,
+ eQuaternion,
+ ePointCloud,
+ ePosition,
+ eOrientation,
+ ePose,
+ eImage,
+ eIntEnum,
+ eInt,
+ eLong,
+ eFloat,
+ eDouble,
+ eString,
+ eBool,
+ eTime,
eUnknown = -1
};
- const std::vector<type::Descriptor> ALL_ARON_TYPES =
+ const std::vector<type::Descriptor> AllDescriptors =
{
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- type::Descriptor::e##upperType,
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
+ Descriptor::eList,
+ Descriptor::eObject,
+ Descriptor::eTuple,
+ Descriptor::ePair,
+ Descriptor::eDict,
+ Descriptor::eNDArray,
+ Descriptor::eMatrix,
+ Descriptor::eQuaternion,
+ Descriptor::ePointCloud,
+ Descriptor::ePosition,
+ Descriptor::eOrientation,
+ Descriptor::ePose,
+ Descriptor::eImage,
+ Descriptor::eIntEnum,
+ Descriptor::eInt,
+ Descriptor::eLong,
+ Descriptor::eFloat,
+ Descriptor::eDouble,
+ Descriptor::eString,
+ Descriptor::eBool,
+ Descriptor::eTime,
Descriptor::eUnknown
};
- const std::map<type::Descriptor, std::string> _descriptor2string =
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { Descriptor::e##upperType, "armarx::aron::type::Descriptor::e" + std::string(#upperType) },
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
- {Descriptor::eUnknown, "armarx::aron::type::Descriptor::eUnknown"}
- };
-
- inline std::string DESCRIPTOR_TO_STRING(const type::Descriptor d)
- {
- return type::_descriptor2string.at(d);
- }
-
- const std::map<type::Maybe, std::string> _maybe2string =
+ namespace defaultconversion::string
{
- {type::Maybe::eNone, "armarx::aron::type::Maybe::eNone"},
- {type::Maybe::eOptional, "armarx::aron::type::Maybe::eOptional"},
- {type::Maybe::eRawPointer, "armarx::aron::type::Maybe::eRawPointer"},
- {type::Maybe::eSharedPointer, "armarx::aron::type::Maybe::eSharedPointer"},
- {type::Maybe::eUniquePointer, "armarx::aron::type::Maybe::eUniquePointer"}
- };
+ // Maybe
+ const std::map<type::Maybe, std::string> Maybe2String =
+ {
+ {Maybe::eNone, "armarx::aron::type::Maybe::eNone"},
+ {Maybe::eRawPointer, "armarx::aron::type::Maybe::eRawPointer"},
+ {Maybe::eSharedPointer, "armarx::aron::type::Maybe::eSharedPointer"},
+ {Maybe::eUniquePointer, "armarx::aron::type::Maybe::eUniquePointer"},
+ {Maybe::eOptional, "armarx::aron::type::Maybe::eOptional"}
+ };
- inline std::string MAYBE_TO_STRING(const type::Maybe d)
- {
- return type::_maybe2string.at(d);
+ // Descriptor
+ const std::map<type::Descriptor, std::string> Descriptor2String =
+ {
+ {Descriptor::eList, "armarx::aron::type::Descriptor::eList"},
+ {Descriptor::eObject, "armarx::aron::type::Descriptor::eObject"},
+ {Descriptor::eDict, "armarx::aron::type::Descriptor::eDict"},
+ {Descriptor::ePair, "armarx::aron::type::Descriptor::ePair"},
+ {Descriptor::eTuple, "armarx::aron::type::Descriptor::eTuple"},
+ {Descriptor::eNDArray, "armarx::aron::type::Descriptor::eNDArray"},
+ {Descriptor::eMatrix, "armarx::aron::type::Descriptor::eMatrix"},
+ {Descriptor::eOrientation, "armarx::aron::type::Descriptor::eOrientation"},
+ {Descriptor::eQuaternion, "armarx::aron::type::Descriptor::eQuaternion"},
+ {Descriptor::eImage, "armarx::aron::type::Descriptor::eImage"},
+ {Descriptor::ePointCloud, "armarx::aron::type::Descriptor::ePointCloud"},
+ {Descriptor::eNDArray, "armarx::aron::type::Descriptor::eNDArray"},
+ {Descriptor::ePose, "armarx::aron::type::Descriptor::ePose"},
+ {Descriptor::ePosition, "armarx::aron::type::Descriptor::ePosition"},
+ {Descriptor::eIntEnum, "armarx::aron::type::Descriptor::eIntEnum"},
+ {Descriptor::eInt, "armarx::aron::type::Descriptor::eInt"},
+ {Descriptor::eLong, "armarx::aron::type::Descriptor::eLong"},
+ {Descriptor::eFloat, "armarx::aron::type::Descriptor::eFloat"},
+ {Descriptor::eDouble, "armarx::aron::type::Descriptor::eDouble"},
+ {Descriptor::eString, "armarx::aron::type::Descriptor::eString"},
+ {Descriptor::eBool, "armarx::aron::type::Descriptor::eBool"},
+ {Descriptor::eTime, "armarx::aron::type::Descriptor::eTime"},
+ {Descriptor::eUnknown, "armarx::aron::type::Descriptor::eUnknown"}
+ };
}
- const std::map<std::string, type::Descriptor> _string2descriptor =
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { "armarx::aron::type::Descriptor::e" + std::string(#upperType), Descriptor::e##upperType }, \
- { std::string(#upperType), Descriptor::e##upperType }, \
- { std::string(#lowerType), Descriptor::e##upperType }, \
- { std::string(#capsType), Descriptor::e##upperType },
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
- {"armarx::aron::type::Descriptor::eUnknown", Descriptor::eUnknown},
- {"Unknown", Descriptor::eUnknown},
- {"unknown", Descriptor::eUnknown},
- {"UNKNOWN", Descriptor::eUnknown}
- };
-
- inline type::Descriptor STRING_TO_DESCRIPTOR(const std::string& s)
+ namespace defaultconversion::typeinfo
{
- return type::_string2descriptor.at(s);
+ // hash type
+ const std::map<size_t, Descriptor> TypeId2Descriptor = {
+ {typeid(aron::type::dto::List).hash_code(), Descriptor::eList},
+ {typeid(aron::type::dto::AronObject).hash_code(), Descriptor::eObject},
+ {typeid(aron::type::dto::Tuple).hash_code(), Descriptor::eTuple},
+ {typeid(aron::type::dto::Pair).hash_code(), Descriptor::ePair},
+ {typeid(aron::type::dto::Dict).hash_code(), Descriptor::eDict},
+ {typeid(aron::type::dto::NDArray).hash_code(), Descriptor::eNDArray},
+ {typeid(aron::type::dto::Matrix).hash_code(), Descriptor::eMatrix},
+ {typeid(aron::type::dto::Quaternion).hash_code(), Descriptor::eQuaternion},
+ {typeid(aron::type::dto::PointCloud).hash_code(), Descriptor::ePointCloud},
+ {typeid(aron::type::dto::Position).hash_code(), Descriptor::ePosition},
+ {typeid(aron::type::dto::Orientation).hash_code(), Descriptor::eOrientation},
+ {typeid(aron::type::dto::Pose).hash_code(), Descriptor::ePose},
+ {typeid(aron::type::dto::Image).hash_code(), Descriptor::eImage},
+ {typeid(aron::type::dto::IntEnum).hash_code(), Descriptor::eIntEnum},
+ {typeid(aron::type::dto::AronInt).hash_code(), Descriptor::eInt},
+ {typeid(aron::type::dto::AronFloat).hash_code(), Descriptor::eFloat},
+ {typeid(aron::type::dto::AronLong).hash_code(), Descriptor::eLong},
+ {typeid(aron::type::dto::AronDouble).hash_code(), Descriptor::eDouble},
+ {typeid(aron::type::dto::AronString).hash_code(), Descriptor::eString},
+ {typeid(aron::type::dto::AronBool).hash_code(), Descriptor::eBool},
+ {typeid(aron::type::dto::AronTime).hash_code(), Descriptor::eTime}
+ };
}
- inline type::Descriptor DESCRIPTOR_FROM_STRING(const std::string& s)
+ inline type::Descriptor Aron2Descriptor(const type::dto::GenericType& t)
{
- return STRING_TO_DESCRIPTOR(s);
+ return defaultconversion::typeinfo::TypeId2Descriptor.at(typeid(t).hash_code());
}
}
@@ -125,62 +247,68 @@ namespace armarx::aron::data
{
enum class Descriptor
{
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- e##upperType,
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
+ eList,
+ eDict,
+ eNDArray,
+ eInt,
+ eLong,
+ eFloat,
+ eDouble,
+ eString,
+ eBool,
eUnknown = -1
};
- const std::vector<data::Descriptor> ALL_ARON_DATA =
+ const std::vector<data::Descriptor> AllDescriptors =
{
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- data::Descriptor::e##upperType,
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
+ Descriptor::eList,
+ Descriptor::eDict,
+ Descriptor::eNDArray,
+ Descriptor::eInt,
+ Descriptor::eLong,
+ Descriptor::eFloat,
+ Descriptor::eDouble,
+ Descriptor::eString,
+ Descriptor::eBool,
Descriptor::eUnknown
};
- const std::map<data::Descriptor, std::string> _descriptor2string =
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { Descriptor::e##upperType, "armarx::aron::data::Descriptor::e" + std::string(#upperType) },
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
- {Descriptor::eUnknown, "armarx::aron::data::Descriptor::eUnknown"}
- };
-
- inline std::string DESCRIPTOR_TO_STRING(const data::Descriptor d)
+ namespace defaultconversion::string
{
- return data::_descriptor2string.at(d);
+ // Descriptor
+ const std::map<data::Descriptor, std::string> Descriptor2String =
+ {
+ {Descriptor::eList, "armarx::aron::data::Descriptor::eList"},
+ {Descriptor::eDict, "armarx::aron::data::Descriptor::eDict"},
+ {Descriptor::eNDArray, "armarx::aron::data::Descriptor::eNDArray"},
+ {Descriptor::eInt, "armarx::aron::data::Descriptor::eInt"},
+ {Descriptor::eLong, "armarx::aron::data::Descriptor::eLong"},
+ {Descriptor::eFloat, "armarx::aron::data::Descriptor::eFloat"},
+ {Descriptor::eDouble, "armarx::aron::data::Descriptor::eDouble"},
+ {Descriptor::eString, "armarx::aron::data::Descriptor::eString"},
+ {Descriptor::eBool, "armarx::aron::data::Descriptor::eBool"},
+ {Descriptor::eUnknown, "armarx::aron::data::Descriptor::eUnknown"}
+ };
}
- const std::map<std::string, data::Descriptor> _string2descriptor =
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { "armarx::aron::data::Descriptor::e" + std::string(#upperType), Descriptor::e##upperType }, \
- { std::string(#upperType), Descriptor::e##upperType }, \
- { std::string(#lowerType), Descriptor::e##upperType }, \
- { std::string(#capsType), Descriptor::e##upperType },
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
- {"armarx::aron::data::Descriptor::eUnknown", Descriptor::eUnknown},
- {"Unknown", Descriptor::eUnknown},
- {"unknown", Descriptor::eUnknown},
- {"UNKNOWN", Descriptor::eUnknown}
- };
-
- inline data::Descriptor STRING_TO_DESCRIPTOR(const std::string& s)
+ namespace defaultconversion::typeinfo
{
- return data::_string2descriptor.at(s);
+ // TypeID
+ const std::map<size_t, Descriptor> TypeId2Descriptor = {
+ {typeid(aron::data::dto::List).hash_code(), Descriptor::eList},
+ {typeid(aron::data::dto::Dict).hash_code(), Descriptor::eDict},
+ {typeid(aron::data::dto::NDArray).hash_code(), Descriptor::eNDArray},
+ {typeid(aron::data::dto::AronInt).hash_code(), Descriptor::eInt},
+ {typeid(aron::data::dto::AronFloat).hash_code(), Descriptor::eFloat},
+ {typeid(aron::data::dto::AronLong).hash_code(), Descriptor::eLong},
+ {typeid(aron::data::dto::AronDouble).hash_code(), Descriptor::eDouble},
+ {typeid(aron::data::dto::AronString).hash_code(), Descriptor::eString},
+ {typeid(aron::data::dto::AronBool).hash_code(), Descriptor::eBool},
+ };
}
- inline data::Descriptor DESCRIPTOR_FROM_STRING(const std::string& s)
+ inline data::Descriptor Aron2Descriptor(const data::dto::GenericData& t)
{
- return STRING_TO_DESCRIPTOR(s);
+ return defaultconversion::typeinfo::TypeId2Descriptor.at(typeid(t).hash_code());
}
}
diff --git a/source/RobotAPI/libraries/aron/core/Exception.cpp b/source/RobotAPI/libraries/aron/core/Exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c27cbdfd59b8b16efa2f56570e4e98d3a80391a4
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/Exception.cpp
@@ -0,0 +1,24 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Exception.h"
diff --git a/source/RobotAPI/libraries/aron/core/Exception.h b/source/RobotAPI/libraries/aron/core/Exception.h
index 025328edaa8360ed6a31864b91d4dcb030c8ff60..05e78204366d766518db7bf161d1580880f3299a 100644
--- a/source/RobotAPI/libraries/aron/core/Exception.h
+++ b/source/RobotAPI/libraries/aron/core/Exception.h
@@ -32,177 +32,103 @@
#include <RobotAPI/libraries/aron/core/Path.h>
#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
namespace armarx::aron::error
{
+ /**
+ * @brief A base class for aron exceptions. All aron exceptions inherit from this class
+ */
class AronException :
public armarx::LocalException
{
public:
AronException() = delete;
- AronException(const std::string& caller, const std::string& method, const std::string& reason) :
- LocalException(caller + "::" + method + ": " + reason + ".")
+ AronException(const std::string& prettymethod, const std::string& reason) :
+ LocalException(prettymethod + ": " + reason + ".")
{
-
}
- AronException(const std::string& caller, const std::string& method, const std::string& reason, const Path& path) :
- LocalException(caller + "::" + method + ": " + reason + ". The path was: " + path.toString())
+ AronException(const std::string& prettymethod, const std::string& reason, const Path& path) :
+ LocalException(prettymethod + ": " + reason + ". The path was: " + path.toString())
{
-
}
};
+ /**
+ * @brief The NotImplementedYetException class
+ */
class NotImplementedYetException :
public AronException
{
public:
NotImplementedYetException() = delete;
- NotImplementedYetException(const std::string& caller, const std::string& method) :
- AronException(caller, method, "This method is not yet implemented!")
+ NotImplementedYetException(const std::string& prettymethod) :
+ AronException(prettymethod, "This method is not yet implemented!")
{
-
}
};
+ /**
+ * @brief The AronNotValidException class. Takes a dto object as input
+ */
class AronNotValidException :
public AronException
{
public:
AronNotValidException() = delete;
- AronNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const data::AronDataPtr& data) :
- AronException(caller, method, reason + ". The ice_id of the data was: " + data->ice_id())
- {
-
- }
-
- AronNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const data::AronDataPtr& data, const Path& path) :
- AronException(caller, method, reason + ". The ice_id of the data was: " + data->ice_id(), path)
- {
-
- }
-
- AronNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::AronTypePtr& type) :
- AronException(caller, method, reason + ". The ice_id of the type was: " + type->ice_id())
- {
-
- }
-
- AronNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::AronTypePtr& type, const Path& path) :
- AronException(caller, method, reason + ". The ice_id of the type was: " + type->ice_id(), path)
- {
-
- }
- };
-
- class DescriptorNotValidException :
- public AronException
- {
- public:
- DescriptorNotValidException() = delete;
- DescriptorNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::Descriptor& type) :
- AronException(caller, method, reason + ". The name of the type-enum was: " + type::DESCRIPTOR_TO_STRING(type))
- {
-
- }
-
- DescriptorNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::Descriptor& type, const Path& path) :
- AronException(caller, method, reason + ". The name of the type-enum was: " + type::DESCRIPTOR_TO_STRING(type), path)
- {
-
- }
-
- DescriptorNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const data::Descriptor& data) :
- AronException(caller, method, reason + ". The name of the data-enum was: " + data::DESCRIPTOR_TO_STRING(data))
- {
-
- }
-
- DescriptorNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const data::Descriptor& data, const Path& path) :
- AronException(caller, method, reason + ". The name of the data-enum was: " + data::DESCRIPTOR_TO_STRING(data), path)
- {
-
- }
- };
-
- class MaybeNotValidException :
- public AronException
- {
- public:
- MaybeNotValidException() = delete;
- MaybeNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::Maybe maybe) :
- AronException(caller, method, reason + ". The name of the maybe-type was: " + type::MAYBE_TO_STRING(maybe))
- {
-
- }
-
- MaybeNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const type::Maybe maybe, const Path& path) :
- AronException(caller, method, reason + ". The name of the maybe-type was: " + type::MAYBE_TO_STRING(maybe), path)
+ AronNotValidException(const std::string& prettymethod, const std::string& reason, const data::dto::GenericDataPtr& data) :
+ AronException(prettymethod, reason + ". The ice_id of the data was: " + data->ice_id())
{
}
- };
- class StringNotValidException :
- public AronException
- {
- public:
- StringNotValidException() = delete;
- StringNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const std::string& input) :
- AronException(caller, method, reason + ". Got: " + input)
+ AronNotValidException(const std::string& prettymethod, const std::string& reason, const data::dto::GenericDataPtr& data, const Path& path) :
+ AronException(prettymethod, reason + ". The ice_id of the data was: " + data->ice_id(), path)
{
}
- StringNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const std::string& input, const Path& path) :
- AronException(caller, method, reason + ". Got: " + input, path)
+ AronNotValidException(const std::string& prettymethod, const std::string& reason, const type::dto::GenericTypePtr& type) :
+ AronException(prettymethod, reason + ". The ice_id of the type was: " + type->ice_id())
{
}
- StringNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const std::string& input, const std::string& expectation) :
- AronException(caller, method, reason + ". Got: " + input + ". Expected: " + expectation)
- {
-
- }
-
- StringNotValidException(const std::string& caller, const std::string& method, const std::string& reason, const std::string& input, const std::string& expectation, const Path& path) :
- AronException(caller, method, reason + ". Got: " + input + ". Expected: " + expectation, path)
+ AronNotValidException(const std::string& prettymethod, const std::string& reason, const type::dto::GenericTypePtr& type, const Path& path) :
+ AronException(prettymethod, reason + ". The ice_id of the type was: " + type->ice_id(), path)
{
}
};
- class IndexNotValidException :
+ /**
+ * @brief The ValueNotValidException class. Only takes strings as input (convert before)
+ */
+ class ValueNotValidException :
public AronException
{
public:
- IndexNotValidException() = delete;
- IndexNotValidException(const std::string& caller, const std::string& method, const std::string& reason, int real, int expected) :
- AronException(caller, method, reason + ". The requested index is: " + std::to_string(real) + ". The maximum index was: " + std::to_string(expected))
+ ValueNotValidException() = delete;
+ ValueNotValidException(const std::string& prettymethod, const std::string& reason, const std::string& input) :
+ AronException(prettymethod, reason + ". Got: " + input)
{
}
- IndexNotValidException(const std::string& caller, const std::string& method, const std::string& reason, int real, int expected, const Path& path) :
- AronException(caller, method, reason + ". The requested index is: " + std::to_string(real) + ". The maximum index was: " + std::to_string(expected), path)
+ ValueNotValidException(const std::string& prettymethod, const std::string& reason, const std::string& input, const Path& path) :
+ AronException(prettymethod, reason + ". Got: " + input, path)
{
}
- };
- class SizeNotValidException :
- public AronException
- {
- public:
- SizeNotValidException() = delete;
- SizeNotValidException(const std::string& caller, const std::string& method, const std::string& reason, int real, int expected) :
- AronException(caller, method, reason + ". The measured size is: " + std::to_string(real) + ". The expected size was: " + std::to_string(expected))
+ ValueNotValidException(const std::string& prettymethod, const std::string& reason, const std::string& input, const std::string& expectation) :
+ AronException(prettymethod, reason + ". Got: " + input + ". Expected: " + expectation)
{
}
- SizeNotValidException(const std::string& caller, const std::string& method, const std::string& reason, int real, int expected, const Path& path) :
- AronException(caller, method, reason + ". The measured size is: " + std::to_string(real) + ". The expected size was: " + std::to_string(expected), path)
+ ValueNotValidException(const std::string& prettymethod, const std::string& reason, const std::string& input, const std::string& expectation, const Path& path) :
+ AronException(prettymethod, reason + ". Got: " + input + ". Expected: " + expectation, path)
{
}
diff --git a/source/RobotAPI/libraries/aron/core/Path.cpp b/source/RobotAPI/libraries/aron/core/Path.cpp
index a9fbd9c8bf979414766d310d0ae35b9b98fc9055..98d3a574be3fb44e0fb75067fb5e18273d47e713 100644
--- a/source/RobotAPI/libraries/aron/core/Path.cpp
+++ b/source/RobotAPI/libraries/aron/core/Path.cpp
@@ -121,7 +121,7 @@ namespace armarx::aron
{
if (!hasElement())
{
- throw error::AronException("NavigatorPath", "getLastElement", "Try to access last element of empty vector.");
+ throw error::AronException(__PRETTY_FUNCTION__, "Try to access last element of empty vector.");
}
return path.back();
}
@@ -130,7 +130,7 @@ namespace armarx::aron
{
if (!hasElement())
{
- throw error::AronException("NavigatorPath", "getFirstElement", "Try to access last element of empty vector.");
+ throw error::AronException(__PRETTY_FUNCTION__, "Try to access last element of empty vector.");
}
return path[0];
}
diff --git a/source/RobotAPI/libraries/aron/core/Path.h b/source/RobotAPI/libraries/aron/core/Path.h
index b9eb3f6108852b2eb6d2e22e935f2b634385a1cc..ab96e3fb87a2fe48b98b51a5daceeb4defe4b700 100644
--- a/source/RobotAPI/libraries/aron/core/Path.h
+++ b/source/RobotAPI/libraries/aron/core/Path.h
@@ -29,17 +29,38 @@
namespace armarx::aron
{
+ /**
+ * @brief The Path class. It is used to keep track of the internal tree-like structure of a variant and can be converted into a string for debugging purposes and exception message generation.
+ * Further, it can be used to navigate through a type or data object
+ */
class Path
{
public:
+ /// default constructor
Path();
+
+ /// constructor, taking a list of strings (a path)
Path(const std::vector<std::string>&);
+
+ /// constructor for setting the root identifier and the delimeter
Path(const std::string&, const std::string&);
+
+ /// constructor for setting the root identifier and the delimeter and the path
Path(const std::string&, const std::string&, const std::vector<std::string>&);
+
+ /// copy constructor
Path(const Path&);
+
+ /// append constructor
Path(const Path&, const std::string&);
+
+ /// append constructor
Path(const Path&, const std::string&, const std::string&);
+
+ /// append constructor
Path(const Path&, const std::vector<std::string>&);
+
+ /// comparison operator
Path& operator=(const armarx::aron::Path&) = default;
std::vector<std::string> getPath() const;
diff --git a/source/RobotAPI/libraries/aron/core/Randomizer.h b/source/RobotAPI/libraries/aron/core/Randomizer.h
deleted file mode 100644
index 170f4b2b8b1a471a09ff0e4cf9b51a05c1470fe7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Randomizer.h
+++ /dev/null
@@ -1,526 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <map>
-#include <memory>
-#include <numeric>
-#include <set>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx::aron
-{
- class Randomizer
- {
- public:
- Randomizer()
- {
- initializeSelf();
- };
-
- typenavigator::NavigatorPtr generateRandomType(bool allowMaybeType = false, bool firstObject = false) const
- {
- type::Descriptor nextType = type::Descriptor::eObject;
- if (!firstObject)
- {
- nextType = getRandomElement(type::ALL_ARON_TYPES);
- }
-
- type::Maybe nextMaybeType = type::Maybe::eNone;
- if (allowMaybeType && !firstObject)
- {
- nextMaybeType = getRandomElement(type::ALL_MAYBE_TYPES);
- }
- (void) nextMaybeType; // Unused
-
- switch (nextType)
- {
- case type::Descriptor::eObject:
- {
- auto t = std::make_shared<typenavigator::ObjectNavigator>();
- std::string objectName = generateRandomWord();
- t->setObjectName(objectName);
-
- int members = generateRandom(4, 2);
- std::set<std::string> usedKeys = {objectName};
- for (int i = 0; i < members; ++i)
- {
- std::string key = generateRandomWord(usedKeys);
- usedKeys.insert(key);
-
- typenavigator::NavigatorPtr m = generateRandomType(false);
- t->addMemberType(key, m);
- }
- return t;
- }
- case type::Descriptor::eIntEnum:
- {
- auto t = std::make_shared<typenavigator::IntEnumNavigator>();
- std::string intEnumName = generateRandomWord();
- t->setEnumName(intEnumName);
-
- std::set<std::string> usedKeys = {intEnumName};
- for (int i = 0; i < generateRandom(5, 2); ++i)
- {
- std::string key = generateRandomWord(usedKeys);
- usedKeys.insert(key);
-
- t->addAcceptedValue(key, i);
- }
- return t;
- }
- case type::Descriptor::eDict:
- {
- auto t = std::make_shared<typenavigator::DictNavigator>();
- typenavigator::NavigatorPtr a = generateRandomType(false);
-
- t->setAcceptedType(a);
- return t;
- }
- case type::Descriptor::eTuple:
- {
- auto t = std::make_shared<typenavigator::TupleNavigator>();
-
- int members = generateRandom(4, 2);
- for (int i = 0; i < members; ++i)
- {
- typenavigator::NavigatorPtr m = generateRandomType(false);
- t->addAcceptedType(m);
- }
- return t;
- }
- case type::Descriptor::eList:
- {
- auto t = std::make_shared<typenavigator::ListNavigator>();
- typenavigator::NavigatorPtr a = generateRandomType(false);
-
- t->setAcceptedType(a);
- return t;
- }
- case type::Descriptor::ePair:
- {
- auto t = std::make_shared<typenavigator::PairNavigator>();
- typenavigator::NavigatorPtr a = generateRandomType(false);
- typenavigator::NavigatorPtr b = generateRandomType(false);
-
- t->setFirstAcceptedType(a);
- t->setSecondAcceptedType(b);
- return t;
- }
- case type::Descriptor::eNDArray:
- {
- // TODO (fabian.peller)
- // fall through EigenMatrix
- }
- case type::Descriptor::eEigenMatrix:
- {
- auto t = std::make_shared<typenavigator::EigenMatrixNavigator>();
- auto type = getRandomKey(t->ACCEPTED_TYPES);
- t->setTypename(type);
- t->setRows(generateRandom(10, 1));
- t->setRows(generateRandom(10, 1));
- return t;
- }
- case type::Descriptor::eEigenQuaternion:
- {
- auto t = std::make_shared<typenavigator::EigenQuaternionNavigator>();
- auto type = getRandomKey(t->ACCEPTED_TYPES);
- t->setTypename(type);
- return t;
- }
- case type::Descriptor::eImage:
- {
- auto t = std::make_shared<typenavigator::ImageNavigator>();
- auto type = getRandomKey(typenavigator::ImageNavigator::pixelTypeNames());
- return t;
- }
- case type::Descriptor::eIVTCByteImage:
- {
- auto t = std::make_shared<typenavigator::IVTCByteImageNavigator>();
- auto type = getRandomKey(t->ACCEPTED_TYPES);
- return t;
- }
- case type::Descriptor::eOpenCVMat:
- {
- auto t = std::make_shared<typenavigator::OpenCVMatNavigator>();
- auto type = getRandomKey(t->ACCEPTED_TYPES);
- return t;
- }
- case type::Descriptor::ePCLPointCloud:
- {
- auto t = std::make_shared<typenavigator::PCLPointCloudNavigator>();
- auto type = getRandomKey(t->ACCEPTED_TYPES);
- t->setTypename(type);
- return t;
- }
- case type::Descriptor::ePosition:
- {
- auto t = std::make_shared<typenavigator::PositionNavigator>();
- return t;
- }
- case type::Descriptor::eOrientation:
- {
- auto t = std::make_shared<typenavigator::PositionNavigator>();
- return t;
- }
- case type::Descriptor::ePose:
- {
- auto t = std::make_shared<typenavigator::PositionNavigator>();
- return t;
- }
- case type::Descriptor::eInt:
- {
- auto t = std::make_shared<typenavigator::IntNavigator>();
- return t;
- }
- case type::Descriptor::eLong:
- {
- auto t = std::make_shared<typenavigator::LongNavigator>();
- return t;
- }
- case type::Descriptor::eFloat:
- {
- auto t = std::make_shared<typenavigator::FloatNavigator>();
- return t;
- }
- case type::Descriptor::eDouble:
- {
- auto t = std::make_shared<typenavigator::DoubleNavigator>();
- return t;
- }
- case type::Descriptor::eString:
- {
- auto t = std::make_shared<typenavigator::StringNavigator>();
- return t;
- }
- case type::Descriptor::eBool:
- {
- auto t = std::make_shared<typenavigator::BoolNavigator>();
- return t;
- }
- case type::Descriptor::eTime:
- {
- auto t = std::make_shared<typenavigator::TimeNavigator>();
- return t;
- }
- case type::Descriptor::eUnknown:
- {
- throw error::DescriptorNotValidException("Randomizer", "generateRandomType", "No valid type found!", nextType);
- }
- }
- }
-
- datanavigator::NavigatorPtr generateEmptyAronDataFromType(const typenavigator::NavigatorPtr& type, bool ignore_maybe = false) const
- {
- if (type->getMaybe() != type::Maybe::eNone && !ignore_maybe)
- {
- if (fiftyPercentChance())
- {
- return nullptr;
- }
- }
-
- const type::Descriptor desc = type->getDescriptor();
- switch (desc)
- {
- // In an object, we do not want to edit the keys.
- case type::Descriptor::eObject:
- {
- typenavigator::ObjectNavigatorPtr t = typenavigator::ObjectNavigator::DynamicCastAndCheck(type);
- auto d = std::make_shared<datanavigator::DictNavigator>();
- for (const auto& [k, tt] : t->getMemberTypes())
- {
- d->addElement(k, generateEmptyAronDataFromType(tt));
- }
- return d;
- }
-
- case type::Descriptor::eIntEnum:
- {
- auto t = typenavigator::IntEnumNavigator::DynamicCastAndCheck(type);
- auto d = std::make_shared<datanavigator::IntNavigator>();
- return d;
- }
-
- // here all totally random
- case type::Descriptor::eDict:
- {
- auto t = typenavigator::DictNavigator::DynamicCastAndCheck(type);
- return datanavigator::NavigatorPtr(new datanavigator::DictNavigator());
- }
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-case type::Descriptor::e##upperType: \
-{ \
- auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
- return datanavigator::NavigatorPtr(new datanavigator::ListNavigator()); \
-}
-
- HANDLE_LIST_SERIALIZER_TYPES
-#undef RUN_ARON_MACRO
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-case type::Descriptor::e##upperType: \
-{ \
- auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
- return datanavigator::NDArrayNavigatorPtr(new datanavigator::NDArrayNavigator()); \
-}
-
- HANDLE_NDARRAY_TYPES
-#undef RUN_ARON_MACRO
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType, upperData, lowerData, capsData) \
-case type::Descriptor::e##upperType: \
-{ \
- auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
- return datanavigator::NavigatorPtr(new datanavigator::upperData##Navigator()); \
-}
-
- HANDLE_PRIMITIVE_CORRESPONDING
-#undef RUN_ARON_MACRO
- case type::Descriptor::eUnknown:
- {
- throw error::DescriptorNotValidException("Randomizer", "generateAronDataFromType", "No valid type found!", desc);
- }
- }
- // end of non void....... dont know why
- return nullptr;
- }
-
- void initializeRandomly(datanavigator::NavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data = generateEmptyAronDataFromType(type);
- if (!data)
- {
- if (type->getMaybe() == type::Maybe::eNone)
- {
- throw error::AronException("Randomizer", "initializeRandomly", "The data is null but the type is not a maybe type. This is not valid.");
- }
- return;
- }
-
- // Containers
- type::Descriptor desc = type->getDescriptor();
- switch (desc)
- {
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType, upperData, lowerData, capsData) \
-case type::Descriptor::e##upperType: \
-{ \
- typenavigator::upperType##NavigatorPtr t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
- datanavigator::upperData##NavigatorPtr d = datanavigator::upperData##Navigator::DynamicCastAndCheck(data); \
- initializeRandomly(d, t); \
- break; \
-}
-
- HANDLE_ALL_CORRESPONDING
-#undef RUN_ARON_MACRO
-
- case type::Descriptor::eUnknown:
- {
- throw error::DescriptorNotValidException("Randomizer", "initializeRandomly", "No valid type found!", desc);
- }
- }
- }
-
- // generate i in [min, max)
- int generateRandom(int max, int min) const
- {
- if (max < min)
- {
- throw error::IndexNotValidException("AronRandomizer", "generateRandom", "The max value is lower than the min value", max, min);
- }
- int random = (std::rand() % (max - min)) + min;
- return random;
- }
-
- template <class T>
- T getRandomElement(const std::vector<T>& vec) const
- {
- int i = generateRandom(vec.size(), 0);
- return vec.at(i);
- }
-
- template <class ValueT>
- std::string getRandomKey(const std::map<std::string, ValueT>& m) const
- {
- std::vector<std::string> keys;
- for (const auto [k, _] : m)
- {
- keys.push_back(k);
- }
- return getRandomElement(keys);
- }
-
- std::string getRandomKey(const std::set<std::string>& set) const
- {
- std::vector<std::string> keys;
- for (const auto k : set)
- {
- keys.push_back(k);
- }
- return getRandomElement(keys);
- }
-
- bool fiftyPercentChance() const
- {
- return generateRandom(2, 0);
- }
-
- std::string generateRandomWord(const std::set<std::string>& usedKeys = {}) const
- {
- // https://randomwordgenerator.com/
- // script to convert random words into string:
- // jQuery("#result li i").remove(); var str = ""; jQuery("#result li").each(function() {str += jQuery(this).html() + ", " }); console.log(str);
- std::vector<string> words =
- {
- "jaw", "river", "bow", "profession", "heat", "interference", "slave", "population", "deport", "redeem", "digress", "penny", "cousin", "beef", "Bible", "fuss",
- "urgency", "tasty", "innovation", "upset", "gold", "day", "remunerate", "strain", "district", "panel", "choke", "rack", "parameter", "despair", "extort", "country",
- "hesitate", "record", "brand", "confusion", "discreet", "accept", "lifestyle", "option", "corn", "charity", "miss", "viable", "glance", "norm", "meet", "bird",
- "ribbon", "guideline"
- };
-
- int i = generateRandom(words.size(), 0);
- std::string key = words.at(i);
-
- while (usedKeys.count(key) > 0)
- {
- key = generateRandomWord(usedKeys);
- }
-
- return key;
- }
-
- std::vector<unsigned char> generateRandomBlob(unsigned int size) const
- {
- std::vector<unsigned char> new_blob(size, 0);
- for (unsigned int i = 0; i < size; ++i)
- {
- new_blob[i] = (generateRandom(128, 0));
- }
- return new_blob;
- }
-
- void initializeRandomly(datanavigator::DictNavigatorPtr& data, const typenavigator::ObjectNavigatorPtr& type) const
- {
- for (auto& [key, nextData] : data->getElements())
- {
- initializeRandomly(nextData, type->getMemberTypes()[key]);
- }
- }
-
- void initializeRandomly(datanavigator::DictNavigatorPtr& data, const typenavigator::DictNavigatorPtr& type) const
- {
- data->clear();
- int numElements = generateRandom(5, 1);
- std::set<std::string> usedKeys;
- for (int i = 0; i < numElements; ++i)
- {
- std::string key = generateRandomWord(usedKeys);
- usedKeys.insert(key);
- datanavigator::NavigatorPtr newData = generateEmptyAronDataFromType(type->getAcceptedType());
- initializeRandomly(newData, type->getAcceptedType());
- data->addElement(key, newData);
- }
- }
-
- void initializeRandomly(datanavigator::ListNavigatorPtr& data, const typenavigator::TupleNavigatorPtr& type) const
- {
- unsigned int i = 0;
- for (auto& nextData : data->getElements())
- {
- initializeRandomly(nextData, type->getAcceptedType(i++));
- }
- }
-
- void initializeRandomly(datanavigator::ListNavigatorPtr& data, const typenavigator::PairNavigatorPtr& type) const
- {
- datanavigator::NavigatorPtr first = data->getElement(0);
- datanavigator::NavigatorPtr second = data->getElement(1);
- initializeRandomly(first, type->getFirstAcceptedType());
- initializeRandomly(second, type->getSecondAcceptedType());
- }
-
- void initializeRandomly(datanavigator::ListNavigatorPtr& data, const typenavigator::ListNavigatorPtr& type) const
- {
- data->clear();
- int numElements = generateRandom(5, 1);
- for (int i = 0; i < numElements; ++i)
- {
- datanavigator::NavigatorPtr newData = generateEmptyAronDataFromType(type->getAcceptedType());
- initializeRandomly(newData, type->getAcceptedType());
- data->addElement(newData);
- }
- }
-
- void initializeRandomly(datanavigator::NDArrayNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- std::vector<int> dims = data->getDimensions();
- int bytes = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
- std::vector<unsigned char> blob = generateRandomBlob(bytes);
- data->setData(bytes, blob.data());
- }
-
- void initializeRandomly(datanavigator::IntNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(generateRandom(1000, -1000));
- }
-
- void initializeRandomly(datanavigator::LongNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(generateRandom(1000, -1000));
- }
-
- void initializeRandomly(datanavigator::FloatNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(generateRandom(1000, -1000));
- }
-
- void initializeRandomly(datanavigator::DoubleNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(generateRandom(1000, -1000));
- }
-
- void initializeRandomly(datanavigator::BoolNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(fiftyPercentChance());
- }
-
- void initializeRandomly(datanavigator::StringNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
- {
- data->setValue(generateRandomWord());
- }
-
- private:
- void initializeSelf() const
- {
- std::srand(std::time(nullptr));
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/Resolver.cpp b/source/RobotAPI/libraries/aron/core/Resolver.cpp
deleted file mode 100644
index 5c3080eebbb6b053343adaf01a1f4a04f1a7c4e7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Resolver.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Simox
-#include <SimoxUtility/meta/type_name.h>
-
-// Header
-#include "Resolver.h"
-
-namespace armarx::aron
-{
- type::Descriptor Resolver::GetDescriptor(const type::AronTypePtr& a)
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { \
- type::Aron##upperType##Ptr aron = type::Aron##upperType##Ptr::dynamicCast(a); \
- if(aron) \
- { \
- return type::Descriptor::e##upperType; \
- } \
- }
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
- throw error::AronNotValidException("Resolver", "GetTypeForAronAbstractType", "Could not cast AronType to a valid type", a);
- }
-
- data::Descriptor Resolver::GetDescriptor(const data::AronDataPtr& a)
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- { \
- data::Aron##upperType##Ptr aron = data::Aron##upperType##Ptr::dynamicCast(a); \
- if(aron) \
- { \
- return data::Descriptor::e##upperType; \
- } \
- }
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
- throw error::AronNotValidException("Resolver", "GetTypeForAronData", "Could not cast AronData to a valid type", a);
- }
-
- bool Resolver::Correspond(const type::Descriptor& t, const data::Descriptor& d)
- {
-#define RUN_ARON_MACRO(typeUpperType, typeLowerType, typeCapsType, dataUpperType, dataLowerType, dataCapsType) \
- if(t == type::Descriptor::e##typeUpperType && d == data::Descriptor::e##dataUpperType) \
- { \
- return true; \
- }
-
- HANDLE_ALL_CORRESPONDING
-#undef RUN_ARON_MACRO
- return false;
- }
-
- type::Descriptor Resolver::GetFirstIfCorrespond(const type::Descriptor& t, const data::Descriptor& d)
- {
- if (Correspond(t, d))
- {
- return t;
- }
- return GetCorresponding(d);
- }
-
- data::Descriptor Resolver::GetCorresponding(const type::Descriptor& d)
- {
-#define RUN_ARON_MACRO(typeUpperType, typeLowerType, typeCapsType, dataUpperType, dataLowerType, dataCapsType) \
- { \
- if(d == type::Descriptor::e##typeUpperType) \
- { \
- return data::Descriptor::e##dataUpperType; \
- } \
- }
- HANDLE_ALL_CORRESPONDING
-#undef RUN_ARON_MACRO
- return data::Descriptor::eUnknown;
- }
-
- type::Descriptor Resolver::GetCorresponding(const data::Descriptor& d)
- {
-#define RUN_ARON_MACRO(typeUpperType, typeLowerType, typeCapsType, dataUpperType, dataLowerType, dataCapsType) \
- { \
- if(d == data::Descriptor::e##dataUpperType) \
- { \
- return type::Descriptor::e##typeUpperType; \
- } \
- }
- HANDLE_ALL_CORRESPONDING
-#undef RUN_ARON_MACRO
- return type::Descriptor::eUnknown;
- }
-
- bool Resolver::AreRelated(const data::Descriptor& d, const data::Descriptor& d2)
- {
- if (d == d2)
- {
- return true;
- }
-#define RUN_ARON_MACRO(data1UpperType, data1LowerType, data1CapsType, data2UpperType, data2LowerType, data2CapsType) \
- if( \
- (d == data::Descriptor::e##data1UpperType && d2 == data::Descriptor::e##data2UpperType) || \
- (d2 == data::Descriptor::e##data1UpperType && d == data::Descriptor::e##data2UpperType) \
- ) \
- { \
- return true; \
- }
-
- HANDLE_ARON_PRIMITIVE_DATA_RELATED
-#undef RUN_ARON_MACRO
- return false;
- }
-
- bool Resolver::AreRelated(const type::Descriptor& t, const type::Descriptor& t2)
- {
- if (t == t2)
- {
- return true;
- }
-#define RUN_ARON_MACRO(type1UpperType, type1LowerType, type1CapsType, type2UpperType, type2LowerType, type2CapsType) \
- if( \
- (t == type::Descriptor::e##type1UpperType && t2 == type::Descriptor::e##type2UpperType) || \
- (t2 == type::Descriptor::e##type1UpperType && t == type::Descriptor::e##type2UpperType) \
- ) \
- { \
- return true; \
- }
-
- HANDLE_ARON_PRIMITIVE_DATA_RELATED
-#undef RUN_ARON_MACRO
- return false;
- }
-
- data::Descriptor Resolver::GetFirstIfRelated(const data::Descriptor& d, const data::Descriptor& d2)
- {
- if (AreRelated(d, d2))
- {
- return d;
- }
- return d2;
- }
-
- type::Descriptor Resolver::GetFirstIfRelated(const type::Descriptor& t, const type::Descriptor& t2)
- {
- if (AreRelated(t, t2))
- {
- return t;
- }
- return t2;
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/Resolver.h b/source/RobotAPI/libraries/aron/core/Resolver.h
deleted file mode 100644
index 8c04597ef1fa5ab5866a1d56d0713ae53aa3e8fb..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/Resolver.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <typeindex>
-#include <typeinfo>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron
-{
- class Resolver
- {
- private: // disallow creating this object. static use only
- Resolver() = delete;
-
- public:
- static type::Descriptor GetDescriptor(const type::AronTypePtr&);
-
- static data::Descriptor GetDescriptor(const data::AronDataPtr&);
-
- static bool Correspond(const type::Descriptor&, const data::Descriptor&);
-
- static type::Descriptor GetFirstIfCorrespond(const type::Descriptor&, const data::Descriptor&);
-
- static data::Descriptor GetCorresponding(const type::Descriptor&);
- static type::Descriptor GetCorresponding(const data::Descriptor&);
-
- static bool AreRelated(const data::Descriptor&, const data::Descriptor&);
- static bool AreRelated(const type::Descriptor&, const type::Descriptor&);
-
- static data::Descriptor GetFirstIfRelated(const data::Descriptor&, const data::Descriptor&);
- static type::Descriptor GetFirstIfRelated(const type::Descriptor&, const type::Descriptor&);
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/IncludeInfo.h b/source/RobotAPI/libraries/aron/core/codegenerator/IncludeInfo.h
deleted file mode 100644
index a6e2eca40e991d9cd24e05bca8fa4a0d70fde065..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/IncludeInfo.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Simon Ottenhaus (simon dot ottenhaus at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-namespace armarx
-{
- namespace aron
- {
- namespace codegeneration
- {
- class AronUseTypeInfo;
- typedef std::shared_ptr<AronUseTypeInfo> AronUseTypeInfoPtr;
-
- class AronUseTypeInfo
- {
- public:
- std::string typeName;
- std::string include;
-
- auto operator<(const AronUseTypeInfo& s) const
- {
- // The typeName must be unique
- return typeName < s.typeName;
- }
- };
- }
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.cpp
deleted file mode 100644
index 4a41ea28147c96625a8129e74d9db9be7e9e8b4f..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.cpp
+++ /dev/null
@@ -1,429 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-
-// Simox
-#include <SimoxUtility/algorithm/string.h>
-
-// Header
-#include "Writer.h"
-
-// ArmarX
-
-namespace armarx::aron::cppserializer
-{
- Writer::Writer(const std::string& producerName, const std::vector<std::string>& additionalIncludesFromXMLFile) :
- CodeWriter(producerName, additionalIncludesFromXMLFile)
- {
- addSpecificWriterMethods();
- addSpecificReaderMethods();
- }
-
- void Writer::addSpecificWriterMethods()
- {
- // The toAron Serializer is visible by default
- {
- codegeneratorhelper::WriterInfoPtr toAron = codegeneratorhelper::WriterInfoPtr(new codegeneratorhelper::WriterInfo());
- toAron->methodName = "toAron";
- toAron->returnType = "armarx::aron::datanavigator::DictNavigatorPtr";
- toAron->writerClassType = "armarx::aron::dataIO::writer::NavigatorWriter";
- toAron->include = "<RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h>";
- toAron->enforceConversion = "armarx::aron::datanavigator::DictNavigator::DynamicCast";
- dataWriters.push_back(toAron);
- }
-
- {
- // The toAron Serializer is visible by default
- codegeneratorhelper::WriterInfoPtr toAronType = codegeneratorhelper::WriterInfoPtr(new codegeneratorhelper::WriterInfo());
- toAronType->methodName = "toAronType";
- toAronType->returnType = "armarx::aron::typenavigator::ObjectNavigatorPtr";
- toAronType->writerClassType = "armarx::aron::typeIO::writer::NavigatorWriter";
- toAronType->include = "<RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.h>";
- toAronType->enforceConversion = "armarx::aron::typenavigator::ObjectNavigator::DynamicCast";
- initialTypeWriters.push_back(toAronType);
- }
-
- // toJSON Method
- {
- codegeneratorhelper::WriterInfoPtr toJSON = codegeneratorhelper::WriterInfoPtr(new codegeneratorhelper::WriterInfo());
- toJSON->methodName = "toJSON";
- toJSON->returnType = "nlohmann::json";
- toJSON->writerClassType = "armarx::aron::dataIO::writer::NlohmannJSONWriter";
- toJSON->include = "<RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h>";
- dataWriters.push_back(toJSON);
- }
- }
-
- void Writer::addSpecificReaderMethods()
- {
- // The toAron Serializer is visible by default
- {
- codegeneratorhelper::ReaderInfoPtr fromAron = codegeneratorhelper::ReaderInfoPtr(new codegeneratorhelper::ReaderInfo());
- fromAron->methodName = "fromAron";
- fromAron->argumentType = "armarx::aron::datanavigator::DictNavigatorPtr";
- fromAron->readerClassType = "armarx::aron::dataIO::reader::NavigatorReader";
- fromAron->include = "<RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.h>";
- dataReaders.push_back(fromAron);
- }
- {
- codegeneratorhelper::ReaderInfoPtr fromAron = codegeneratorhelper::ReaderInfoPtr(new codegeneratorhelper::ReaderInfo());
- fromAron->methodName = "fromAron";
- fromAron->argumentType = "armarx::aron::data::AronDictPtr";
- fromAron->readerClassType = "armarx::aron::dataIO::reader::NavigatorReader";
- dataReaders.push_back(fromAron);
- }
-
- // fromJSON Method
- {
- codegeneratorhelper::ReaderInfoPtr fromJSON = codegeneratorhelper::ReaderInfoPtr(new codegeneratorhelper::ReaderInfo());
- fromJSON->methodName = "fromJSON";
- fromJSON->argumentType = "nlohmann::json";
- fromJSON->readerClassType = "armarx::aron::dataIO::reader::NlohmannJSONReader";
- fromJSON->include = "<RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h>";
- dataReaders.push_back(fromJSON);
- }
- }
-
-
- void Writer::generateTypeObjects(const std::vector<codegeneratorhelper::GenerateObjectInfoPtr>& generateObjects)
- {
- for (const auto& publicGenerateObjectType : generateObjects)
- {
- const auto& nav = publicGenerateObjectType->correspondingType;
-
- //std::cout << "Generating: " << nav->getName() << std::endl;
-
- // Convert to Object type and create class object
- if (nav == nullptr)
- {
- throw error::AronException("ClassCppWriter", "generateTypeClasses", "An received public type is null. Abort due to error!");
- }
-
- auto serializer = std::make_shared<serializer::ObjectClassSerializer>(nav);
-
- CppClassPtr c = setupBasicCppClass(serializer->getFullCppTypename());
- setupMemberFields(c, publicGenerateObjectType->doc_members, serializer);
-
- if (nav->getExtends() != nullptr)
- {
- auto extendsSerializer = std::make_shared<serializer::ObjectClassSerializer>(nav->getExtends());
- c->addInherit("public " + extendsSerializer->getFullCppTypename());
- }
- else
- {
- c->addInherit("public armarx::aron::cppserializer::AronCppClass");
- c->addInclude("<RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h>");
- }
-
- // Add includes and guard
- std::string classDoc = "******************************************\n"
- "* AUTOGENERATED CLASS. Please do NOT edit.\n"
- "******************************************\n";
- if (!publicGenerateObjectType->doc_author.empty() or !publicGenerateObjectType->doc_brief.empty())
- {
- classDoc += (publicGenerateObjectType->doc_brief.empty() ? "" : " * @brief " + publicGenerateObjectType->doc_brief + "\n");
- classDoc += (publicGenerateObjectType->doc_author.empty() ? "" : " * @author " + publicGenerateObjectType->doc_author + "\n");
- }
- c->addClassDoc(classDoc);
- c->setPragmaOnceIncludeGuard(true);
- c->addInclude("<memory>");
- c->addInclude("<string>");
- c->addInclude("<vector>");
- c->addInclude("<map>");
- c->addInclude("<RobotAPI/interface/aron.h>");
- for (const std::string& s : additionalIncludes)
- {
- if (!s.empty())
- {
- c->addInclude(s);
- }
- }
-
- //std::cout << "Generate Type classes" << std::endl;
- generateInnerTypeObjects(c, publicGenerateObjectType->nestedObjects);
-
- // ctor
- c->addCtor(serializer->toCtor(c->getName()));
-
- // Generic methods
- //std::cout << "Generate equals method" << std::endl;
- CppMethodPtr equals = serializer->toEqualsMethod();
- c->addMethod(equals);
-
- //std::cout << "Generate reset method" << std::endl;
- CppMethodPtr resetHard = serializer->toResetHardMethod();
- c->addMethod(resetHard);
-
- //std::cout << "Generate init method" << std::endl;
- CppMethodPtr resetSoft = serializer->toResetSoftMethod();
- c->addMethod(resetSoft);
-
- //std::cout << "Generate writeInit method" << std::endl;
- CppMethodPtr writeType = serializer->toWriteTypeMethod();
- c->addMethod(writeType);
-
- //std::cout << "Generate write method" << std::endl;
- CppMethodPtr write = serializer->toWriteMethod();
- c->addMethod(write);
-
- //std::cout << "Generate read method" << std::endl;
- CppMethodPtr read = serializer->toReadMethod();
- c->addMethod(read);
-
- // Writermethods
- for (const codegeneratorhelper::WriterInfoPtr& info : dataWriters)
- {
- if (!info->include.empty())
- {
- c->addInclude(info->include);
- }
- CppMethodPtr convert = serializer->toSpecializedDataWriterMethod(info->returnType, info->methodName, info->writerClassType, info->enforceConversion);
- c->addMethod(convert);
- }
-
- //std::cout << "set member vars" << std::endl;
-
- // Add methods to set the member variables
- for (const codegeneratorhelper::ReaderInfoPtr& info : dataReaders)
- {
- if (!info->include.empty())
- {
- c->addInclude(info->include);
- }
- CppMethodPtr convert = serializer->toSpecializedDataReaderMethod(info->argumentType, info->methodName, info->readerClassType);
- c->addMethod(convert);
- }
-
- //std::cout << "type writer methods" << std::endl;
-
- // Typewritermethods
- for (const codegeneratorhelper::WriterInfoPtr& info : initialTypeWriters)
- {
- if (!info->include.empty())
- {
- c->addInclude(info->include);
- }
- CppMethodPtr convert = serializer->toSpecializedTypeWriterMethod(info->returnType, info->methodName, info->writerClassType, info->enforceConversion);
- c->addMethod(convert);
- }
-
- //std::cout << "push back" << std::endl;
-
- typeClasses.push_back(c);
- }
- }
-
- void Writer::generateTypeIntEnums(const std::vector<codegeneratorhelper::GenerateIntEnumInfoPtr>& generateIntEnums)
- {
- for (const auto& publicGenerateIntEnumType : generateIntEnums)
- {
- const auto& nav = publicGenerateIntEnumType->correspondingType;
- if (nav == nullptr)
- {
- throw error::AronException("ClassCppWriter", "generateTypeIntEnums", "An received public type is null. Abort due to error!");
- }
-
- auto serializer = std::make_shared<serializer::IntEnumClassSerializer>(nav);
-
- CppClassPtr c = setupBasicCppClass(serializer->getFullCppTypename());
- setupMemberFields(c, publicGenerateIntEnumType->doc_values, serializer);
-
- // Add includes and guard
- std::string classDoc = "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
- "!!!!!!AUTOGENERATED CLASS. Please do NOT edit. Instead, edit the corresponding .xml file!!!!!!\n"
- "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!";
- if (!publicGenerateIntEnumType->doc_author.empty() or !publicGenerateIntEnumType->doc_brief.empty())
- {
- classDoc += "\n/**\n";
- classDoc += (publicGenerateIntEnumType->doc_brief.empty() ? "" : " * @brief " + publicGenerateIntEnumType->doc_brief + "\n");
- classDoc += (publicGenerateIntEnumType->doc_author.empty() ? "" : " * @author " + publicGenerateIntEnumType->doc_author + "\n");
- classDoc += " */";
- }
- c->addClassDoc(classDoc);
- c->setPragmaOnceIncludeGuard(true);
- c->addInclude("<memory>");
- c->addInclude("<string>");
- c->addInclude("<vector>");
- c->addInclude("<map>");
- c->addInclude("<RobotAPI/interface/aron.h>");
-
- c->addInherit("virtual public armarx::aron::cppserializer::AronCppClass");
- c->addInclude("<RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h>");
-
- // ctor
- c->addCtor(serializer->toCtor(c->getName()));
- c->addCtor(serializer->toCopyCtor(c->getName()));
- c->addCtor(serializer->toInnerEnumCtor(c->getName()));
-
- // Specific methods
- CppEnumPtr enumrepresentation = serializer->toInnerEnumDefinition();
- c->addInnerEnum(enumrepresentation);
-
- CppMethodPtr toString = serializer->toToStringMethod();
- c->addMethod(toString);
-
- CppMethodPtr fromString = serializer->toFromStringMethod();
- c->addMethod(fromString);
-
- CppMethodPtr intConversion = serializer->toIntMethod();
- c->addMethod(intConversion);
-
- CppMethodPtr enumAssignment = serializer->toEnumAssignmentMethod();
- c->addMethod(enumAssignment);
-
- CppMethodPtr enumAssignment2 = serializer->toCopyAssignmentMethod();
- c->addMethod(enumAssignment2);
-
- CppMethodPtr enumAssignment3 = serializer->toIntAssignmentMethod();
- c->addMethod(enumAssignment3);
-
- // Generic methods
- //std::cout << "Generate equals method" << std::endl;
- CppMethodPtr equals = serializer->toEqualsMethod();
- c->addMethod(equals);
-
- //std::cout << "Generate reset method" << std::endl;
- CppMethodPtr resetHard = serializer->toResetHardMethod();
- c->addMethod(resetHard);
-
- //std::cout << "Generate init method" << std::endl;
- CppMethodPtr resetSoft = serializer->toResetSoftMethod();
- c->addMethod(resetSoft);
-
- //std::cout << "Generate writeInit method" << std::endl;
- CppMethodPtr writeInitialType = serializer->toWriteTypeMethod();
- c->addMethod(writeInitialType);
-
- //std::cout << "Generate write method" << std::endl;
- CppMethodPtr write = serializer->toWriteMethod();
- c->addMethod(write);
-
- //std::cout << "Generate read method" << std::endl;
- CppMethodPtr read = serializer->toReadMethod();
- c->addMethod(read);
-
- typeClasses.push_back(c);
- }
- }
-
- void Writer::generateInnerTypeObjects(CppClassPtr& classToAdd, const std::map<std::string, codegeneratorhelper::GenerateObjectInfoPtr>& localGenerateTypes)
- {
- // setup inner classes
- for (const auto& [_, localGenerateObjectType] : localGenerateTypes)
- {
- const auto& nav = localGenerateObjectType->correspondingType;
-
- auto serializer = std::make_shared<serializer::ObjectClassSerializer>(nav);
-
- CppClassPtr c = setupBasicCppClass(serializer->getFullCppTypename());
- setupMemberFields(c, localGenerateObjectType->doc_members, serializer);
-
- if (nav->getExtends() != nullptr)
- {
- auto extendsSerializer = std::make_shared<serializer::ObjectClassSerializer>(nav->getExtends());
- c->addInherit("public " + extendsSerializer->getFullCppTypename());
- }
- else
- {
- c->addInherit("public armarx::aron::cppserializer::AronCppClass");
- }
-
- std::string classDoc = "";
- if (!localGenerateObjectType->doc_author.empty() or !localGenerateObjectType->doc_brief.empty())
- {
- classDoc += "/**\n";
- classDoc += (localGenerateObjectType->doc_brief.empty() ? "" : " * @brief " + localGenerateObjectType->doc_brief + "\n");
- classDoc += (localGenerateObjectType->doc_author.empty() ? "" : " * @author " + localGenerateObjectType->doc_author + "\n");
- classDoc += " */";
- }
- c->addClassDoc(classDoc);
-
- CppMethodPtr equals = serializer->toEqualsMethod();
- c->addMethod(equals);
-
- CppMethodPtr resetHard = serializer->toResetHardMethod();
- c->addMethod(resetHard);
-
- CppMethodPtr resetSoft = serializer->toResetSoftMethod();
- c->addMethod(resetSoft);
-
- CppMethodPtr writeInitialType = serializer->toWriteTypeMethod();
- c->addMethod(writeInitialType);
-
- CppMethodPtr write = serializer->toWriteMethod();
- c->addMethod(write);
-
- CppMethodPtr read = serializer->toReadMethod();
- c->addMethod(read);
-
- generateInnerTypeObjects(c, localGenerateObjectType->nestedObjects);
- classToAdd->addInnerClass(c);
- }
- }
-
- CppClassPtr Writer::setupBasicCppClass(const std::string& cppTypename) const
- {
- std::vector<std::string> split = simox::alg::split(cppTypename, "::");
- if (split.size() < 1)
- {
- throw error::AronException("ClassCppWriter", "setupCppClassFromObjectType", "The cpp name of an inner type was empty. Please check the type definition file if all object names are set correctly.");
- }
-
- std::vector<std::string> namespaces(split);
- namespaces.pop_back();
-
- CppClassPtr c = std::make_shared<CppClass>(namespaces, split[split.size() - 1]);
- return c;
- }
-
- void Writer::setupMemberFields(CppClassPtr& c, const std::map<std::string, std::string>& doc_members, const serializer::ObjectClassSerializerPtr& o) const
- {
- auto publicFields = o->getPublicVariableDeclarations("");
- for (const auto& f : publicFields)
- {
- if (auto it = doc_members.find(f->getName()); it != doc_members.end())
- {
- f->setDoc("@brief " + it->second);
- }
- c->addPublicField(f);
- }
- }
-
- void Writer::setupMemberFields(CppClassPtr& c, const std::map<std::string, std::string>& doc_members, const serializer::IntEnumClassSerializerPtr& o) const
- {
- auto publicFields = o->getPublicVariableDeclarations("");
- for (const auto& f : publicFields)
- {
- if (auto it = doc_members.find(f->getName()); it != doc_members.end())
- {
- f->setDoc("@brief " + it->second);
- }
- c->addPublicField(f);
- }
- }
-}
-
-
-
-
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/AllSerializers.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/AllSerializers.h
deleted file mode 100644
index 7e1934e88f17b309ce3117d4312557359c300c07..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/AllSerializers.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "container/Object.h"
-#include "container/List.h"
-#include "container/Dict.h"
-#include "container/Tuple.h"
-#include "container/Pair.h"
-#include "ndarray/NDArray.h"
-#include "ndarray/EigenMatrix.h"
-#include "ndarray/EigenQuaternion.h"
-#include "ndarray/Image.h"
-#include "ndarray/IVTCByteImage.h"
-#include "ndarray/OpenCVMat.h"
-#include "ndarray/PCLPointCloud.h"
-#include "ndarray/Position.h"
-#include "ndarray/Orientation.h"
-#include "ndarray/Pose.h"
-#include "enum/IntEnum.h"
-#include "primitive/Int.h"
-#include "primitive/Long.h"
-#include "primitive/Float.h"
-#include "primitive/Double.h"
-#include "primitive/String.h"
-#include "primitive/Bool.h"
-#include "primitive/Time.h"
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.cpp
deleted file mode 100644
index 7cc42a41503cf690be9fccab82acd41b342cfb7b..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.cpp
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
-* Karlsruhe Institute of Technology (KIT), all rights reserved.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-
-#include "Serializer.h"
-#include "SerializerFactory.h"
-
-#include <SimoxUtility/meta/type_name.h>
-#include <SimoxUtility/algorithm/string.h>
-
-
-namespace armarx::aron::cppserializer
-{
- // constantes
- const std::string Serializer::ARON_DATA_NAME = simox::meta::get_type_name<armarx::aron::data::AronData>();
- const std::string Serializer::ARON_DATA_PTR_NAME = Serializer::ARON_DATA_NAME + "::PointerType";
-
- const std::string Serializer::READ_START_RETURN_TYPE_ACCESSOR = "_return_type";
-
- const std::string Serializer::ARON_TYPE_NAME = simox::meta::get_type_name<armarx::aron::type::AronType>();
- const std::string Serializer::ARON_TYPE_PTR_NAME = Serializer::ARON_TYPE_NAME + "::PointerType";
-
- const std::map<std::string, std::string> Serializer::ESCAPE_ACCESSORS =
- {
- {"->", "__ptr__"},
- {".", "__dot__"},
- {"[", "__lbrC__"},
- {"]", "__rbrC__"},
- {"(", "__lbrR__"},
- {")", "__rbrR__"},
- {"*", "__ast__"},
- };
-
- const SerializerFactoryPtr Serializer::FACTORY = SerializerFactoryPtr(new SerializerFactory());
-
-
- // constructors
- Serializer::Serializer(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename) :
- cppTypename(cppName),
- aronDataTypename(aronDataTypename),
- aronTypeTypename(aronTypeTypename)
- {
-
- }
-
- // static methods
- std::string Serializer::ResolveMaybeAccessor(const std::string& s, const typenavigator::NavigatorPtr& t)
- {
- if (t->getMaybe() == type::Maybe::eOptional)
- {
- return s + ".value()";
- }
- if (t->getMaybe() == type::Maybe::eRawPointer || t->getMaybe() == type::Maybe::eSharedPointer || t->getMaybe() == type::Maybe::eUniquePointer)
- {
- return "*" + s;
- }
- return s;
- }
-
- CppBlockPtr Serializer::ResolveMaybeWriteBlock(const std::string& accessor, const CppBlockPtr& block_if_data, const typenavigator::NavigatorPtr& typenavigator)
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
-
- if (!accessor.empty())
- {
- b->addLine("// Generate WriteInterface API calls for " + accessor);
- }
- else
- {
- b->addLine("// Generate WriteInterface API calls for the top level object " + ExtractCppTypename(typenavigator));
- }
-
- if (typenavigator->getMaybe() != type::Maybe::eNone)
- {
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eOptional:
- {
- b->addLine("if (" + accessor + ".has_value())");
- b->addBlock(block_if_data);
- break;
- }
- case type::Maybe::eRawPointer:
- {
- b->addLine("if (" + accessor + " != NULL)");
- b->addBlock(block_if_data);
- break;
- }
- case type::Maybe::eSharedPointer:
- [[fallthrough]];
- case type::Maybe::eUniquePointer:
- {
- b->addLine("if (" + accessor + " != nullptr)");
- b->addBlock(block_if_data);
- break;
- }
- default:
- {
- throw error::MaybeNotValidException("Serializer", "ResolveMaybeWriteBlock", "Unkown Maybe type (perhaps forgot to add in switch case?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- b->addLine("else");
- CppBlockPtr block_if_no_data = std::make_shared<CppBlock>();
- block_if_no_data->addLine("w.writeNull(); // The maybe type '" + accessor + "' has no data, so we simply write NULL (resulting in a AronData nullhandle)");
- b->addBlock(block_if_no_data);
- return b;
- }
- b->appendBlock(block_if_data);
- return b;
- }
-
- CppBlockPtr Serializer::ResolveMaybeReadBlock(const std::string& accessor, const std::string& readElement, const CppBlockPtr& block_if_data, const typenavigator::NavigatorPtr& typenavigator, bool enforce_return_type)
- {
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string read_start_result_accessor = escaped_accessor + READ_START_RETURN_TYPE_ACCESSOR;
-
- CppBlockPtr resolved_block = std::make_shared<CppBlock>();
-
- if (!accessor.empty())
- {
- resolved_block->addLine("// Generate ReadInterface API calls for " + accessor);
- }
- else
- {
- resolved_block->addLine("// Generate ReadInterface API calls for the top level object " + ExtractCppTypename(typenavigator));
- }
-
- if (!readElement.empty())
- {
- if (enforce_return_type or typenavigator->getMaybe() != type::Maybe::eNone)
- {
- resolved_block->addLine("auto " + read_start_result_accessor + " = " + readElement + "; // of " + accessor);
- }
- else
- {
- resolved_block->addLine(readElement + "; // of " + accessor);
- }
- }
-
- if (typenavigator->getMaybe() != type::Maybe::eNone)
- {
- resolved_block->addLine("if (" + read_start_result_accessor + ".success)");
- CppBlockPtr if_success = std::make_shared<CppBlock>();
-
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eOptional:
- {
- auto s = FromAronTypeNaviagtorPtr(typenavigator);
- if_success->addLine(accessor + " = " + s->getFullTypenameGenerator() + "();");
- if_success->appendBlock(block_if_data);
- break;
- }
- case type::Maybe::eRawPointer:
- {
- auto s = FromAronTypeNaviagtorPtr(typenavigator);
- if_success->addLine(accessor + " = " + s->getFullTypenameGenerator() + "();");
- if_success->appendBlock(block_if_data);
- break;
- }
- case type::Maybe::eSharedPointer:
- [[fallthrough]];
- case type::Maybe::eUniquePointer:
- {
- auto s = FromAronTypeNaviagtorPtr(typenavigator);
- if_success->addLine(accessor + " = " + s->getFullTypenameGenerator() + "();");
- if_success->appendBlock(block_if_data);
- break;
- }
- default:
- {
- throw error::MaybeNotValidException("Serializer", "ResolveMaybeReadBlock", "Unkown Maybe type (perhaps forgot to add in switch case?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
- resolved_block->addBlock(if_success);
- return resolved_block;
- }
- resolved_block->appendBlock(block_if_data);
- return resolved_block;
- }
-
- CppBlockPtr Serializer::ResolveMaybeEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor, const CppBlockPtr& block_if_data, const typenavigator::NavigatorPtr& typenavigator)
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
- if (!accessor.empty())
- {
- b->addLine("// Comparing " + accessor + " and " + otherInstanceAccessor);
- }
- else
- {
- b->addLine("// Comparing two objects of type " + ExtractCppTypename(typenavigator));
- }
-
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- {
- b->appendBlock(block_if_data);
- break;
- }
- case type::Maybe::eOptional:
- {
- b->addLine("if (" + accessor + ".has_value() and " + otherInstanceAccessor + ".has_value()) // both have a value set");
- b->addBlock(block_if_data);
- b->addLine("if ((" + accessor + ".has_value() and !" + otherInstanceAccessor + ".has_value()) or (!" + accessor + ".has_value() and " + otherInstanceAccessor + ".has_value())) // only one has a value set (XOR)");
- b->addLine("\t return false;");
- break;
- }
- case type::Maybe::eRawPointer:
- {
- b->addLine("if (" + accessor + " != NULL and " + otherInstanceAccessor + " != NULL) // both have a value set");
- b->addBlock(block_if_data);
- b->addLine("if ((" + accessor + " != NULL and " + otherInstanceAccessor + " == NULL) or (" + accessor + " == NULL and " + otherInstanceAccessor + " != NULL)) // only one has a value set (XOR)");
- b->addLine("\t return false;");
- break;
- }
- case type::Maybe::eSharedPointer:
- [[fallthrough]];
- case type::Maybe::eUniquePointer:
- {
- b->addLine("if (" + accessor + " != nullptr and " + otherInstanceAccessor + " != nullptr) // both have a value set");
- b->addBlock(block_if_data);
- b->addLine("if ((" + accessor + " != nullptr and " + otherInstanceAccessor + " == nullptr) or (" + accessor + " == nullptr and " + otherInstanceAccessor + " != nullptr)) // only one has a value set (XOR)");
- b->addLine("\t return false;");
- break;
- }
- default:
- {
- throw error::MaybeNotValidException("Serializer", "ResolveMaybeEqualsBlock", "Unkown Maybe type (perhaps forgot to add in switch case?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
- return b;
- }
-
- CppBlockPtr Serializer::ResolveMaybeResetSoftBlock(const std::string& accessor, const CppBlockPtr& block_if_data, const typenavigator::NavigatorPtr& typenavigator)
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
-
- if (!accessor.empty())
- {
- b->addLine("// Resetting soft member " + accessor);
- }
- else
- {
- b->addLine("// Resetting soft the type " + ExtractCppTypename(typenavigator));
- }
-
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- {
- b->appendBlock(block_if_data);
- break;
- }
- case type::Maybe::eOptional:
- {
- b->addLine("if (" + accessor + ".has_value())");
- b->addBlock(block_if_data);
- break;
- }
- case type::Maybe::eRawPointer:
- {
- b->addLine("if (" + accessor + " != NULL)");
- b->addBlock(block_if_data);
- break;
- }
- case type::Maybe::eSharedPointer:
- [[fallthrough]];
- case type::Maybe::eUniquePointer:
- {
- b->addLine("if (" + accessor + " != nullptr)");
- b->addBlock(block_if_data);
- break;
- }
- default:
- {
- throw error::MaybeNotValidException("Serializer", "ResolveMaybeResetSoftBlock", "Unkown Maybe type (perhaps forgot to add in switch case?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
- return b;
- }
-
- CppBlockPtr Serializer::ResolveMaybeResetHardBlock(const std::string& accessor, const CppBlockPtr& block_if_data, const typenavigator::NavigatorPtr& typenavigator)
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
- if (!accessor.empty())
- {
- b->addLine("// Resetting hard member " + accessor);
- }
- else
- {
- b->addLine("// Resetting hard the type " + ExtractCppTypename(typenavigator));
- }
-
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- {
- b->appendBlock(block_if_data);
- break;
- }
- case type::Maybe::eOptional:
- [[fallthrough]];
- case type::Maybe::eRawPointer:
- [[fallthrough]];
- case type::Maybe::eSharedPointer:
- [[fallthrough]];
- case type::Maybe::eUniquePointer:
- {
- b->addLine(accessor + " = {};");
- break;
- }
- default:
- {
- throw error::MaybeNotValidException("Serializer", "ResolveMaybeResetSoftBlock", "Unkown Maybe type (perhaps forgot to add in switch case?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
- return b;
- }
-
- std::string Serializer::EscapeAccessor(const std::string& accessor)
- {
- std::string escaped_accessor = accessor;
- for (const auto& [key, value] : ESCAPE_ACCESSORS)
- {
- escaped_accessor = simox::alg::replace_all(escaped_accessor, key, value);
- }
- return escaped_accessor;
- }
-
- std::string Serializer::UnescapeAccessor(const std::string& accessor)
- {
- std::string unescaped_accessor = accessor;
- for (const auto& [key, value] : ESCAPE_ACCESSORS)
- {
- unescaped_accessor = simox::alg::replace_all(unescaped_accessor, value, key);
- }
- return unescaped_accessor;
- }
-
- std::string Serializer::ExtractCppTypename(const typenavigator::NavigatorPtr& n)
- {
- SerializerPtr cpp = Serializer::FromAronTypeNaviagtorPtr(n);
- return cpp->getCoreCppTypename();
- }
-
- std::vector<std::string> Serializer::ExtractCppTypenames(const std::vector<typenavigator::NavigatorPtr>& n)
- {
- std::vector<std::string> ret;
- for (const auto& typenav : n)
- {
- ret.push_back(Serializer::ExtractCppTypename(typenav));
- }
- return ret;
- }
-
- SerializerPtr Serializer::FromAronTypeNaviagtorPtr(const typenavigator::NavigatorPtr& n)
- {
- ARMARX_CHECK_NOT_NULL(n);
- return FACTORY->create(n, n->getPath());
- }
-
- // public methods
- std::string Serializer::getCoreCppTypename() const
- {
- return cppTypename;
- }
-
- std::string Serializer::getAronDataTypename() const
- {
- return aronDataTypename;
- }
-
- std::string Serializer::getAronDataPtrTypename() const
- {
- return getAronDataTypename() + "::PointerType";
- }
-
- std::string Serializer::getAronTypeTypename() const
- {
- return aronTypeTypename;
- }
-
- std::string Serializer::getAronTypePtrTypename() const
- {
- return getAronTypeTypename() + "::PointerType";
- }
-
- CppCtorPtr Serializer::toCtor(const std::string& name) const
- {
- CppCtorPtr c = CppCtorPtr(new CppCtor(name + "()"));
- std::vector<std::pair<std::string, std::string>> initList = this->getCtorInitializers("");
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("resetHard();");
- b->appendBlock(this->getCtorBlock(""));
- c->addInitListEntries(initList);
- c->setBlock(b);
-
- return c;
- }
-
- CppMethodPtr Serializer::toResetSoftMethod() const
- {
- std::stringstream doc;
- doc << "@brief resetSoft() - This method resets all member variables with respect to the current parameterization. \n";
- doc << "@return - nothing";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void resetSoft() override", doc.str()));
- CppBlockPtr b = this->getResetSoftBlock("");
- m->setBlock(b);
- return m;
- }
-
- CppMethodPtr Serializer::toResetHardMethod() const
- {
- std::stringstream doc;
- doc << "@brief resetHard() - This method resets member variables according to the XML type description. \n";
- doc << "@return - nothing";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void resetHard() override", doc.str()));
- CppBlockPtr b = this->getResetHardBlock("");
- m->setBlock(b);
- return m;
- }
-
- CppMethodPtr Serializer::toWriteTypeMethod() const
- {
- std::stringstream doc;
- doc << "@brief writeType() - This method returns a new type from the class structure using a type writer implementation. This function is static. \n";
- doc << "@return - the result of the writer implementation";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("static void writeType(armarx::aron::typeIO::WriterInterface& w, armarx::aron::type::Maybe __aronMaybeType = armarx::aron::type::Maybe::eNone, bool __aronExtends = false)", doc.str()));
- CppBlockPtr b = this->getWriteTypeBlock("");
- m->setBlock(b);
- return m;
- }
-
- CppMethodPtr Serializer::toWriteMethod() const
- {
- std::stringstream doc;
- doc << "@brief write() - This method returns a new type from the member data types using a data writer implementation. \n";
- doc << "@param w - The writer implementation\n";
- doc << "@return - the result of the writer implementation";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void write(armarx::aron::dataIO::WriterInterface& w, bool __aronExtends = false) const override", doc.str()));
- CppBlockPtr b = this->getWriteBlock("");
- m->setBlock(b);
- return m;
- }
-
- CppMethodPtr Serializer::toReadMethod() const
- {
- std::stringstream doc;
- doc << "@brief read() - This method sets the struct members to new values given in a data reader implementation. \n";
- doc << "@param r - The reader implementation\n";
- doc << "@return - nothing";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void read(armarx::aron::dataIO::ReaderInterface& r, bool __aronIsMember = false) override", doc.str()));
- CppBlockPtr b = std::make_shared<CppBlock>();
- b->addLine("this->resetSoft();");
- b->appendBlock(this->getReadBlock(""));
- m->setBlock(b);
- return m;
- }
-
- CppMethodPtr Serializer::toSpecializedDataWriterMethod(const std::string& returnname, const std::string& methodname, const std::string& writerName, const std::string& enforceConversion) const
- {
- std::stringstream doc;
- doc << "@brief specializedDataWrite() - This method returns a new data from the member data types using a writer implementation. \n";
- doc << "@return - the result of the writer implementation";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod(returnname + " " + methodname + "() const", doc.str()));
- m->addLine(writerName + " writer;");
- m->addLine("this->write(writer);");
- m->addLine("return " + enforceConversion + "(writer.getResult());");
- return m;
- }
-
- CppMethodPtr Serializer::toSpecializedDataReaderMethod(const std::string& argumentname, const std::string& methodname, const std::string& readerName, const std::string& enforceConversion) const
- {
- std::stringstream doc;
- doc << "@brief specializedDataRead() - This method sets the struct members to new values given in a reader implementation. \n";
- doc << "@return - nothing";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("void " + methodname + "(const " + argumentname + "& input)", doc.str()));
- m->addLine(readerName + " reader(" + enforceConversion + "(input));");
- m->addLine("this->read(reader);");
- return m;
- }
-
- CppMethodPtr Serializer::toSpecializedTypeWriterMethod(const std::string& returnname, const std::string& methodname, const std::string& writerName, const std::string& enforceConversion) const
- {
- std::stringstream doc;
- doc << "@brief specializedTypeWrite() - This method returns a new type from the member data types using a writer implementation. \n";
- doc << "@return - the result of the writer implementation";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("static " + returnname + " " + methodname + "()", doc.str()));
- m->addLine(writerName + " writer;");
- m->addLine("writeType(writer);");
- m->addLine("return " + enforceConversion + "(writer.getResult());");
- return m;
- }
-
- CppMethodPtr Serializer::toEqualsMethod() const
- {
- std::stringstream doc;
- doc << "@brief operator==() - This method checks whether all values equal another instance. \n";
- doc << "@param i - The other instance\n";
- doc << "@return - true, if all members are the same, false otherwise";
-
- CppMethodPtr m = CppMethodPtr(new CppMethod("bool operator==(const " + this->getFullCppTypename() + "& i) const", doc.str()));
- CppBlockPtr b = this->getEqualsBlock("", "i");
- b->addLine("return true;");
- m->setBlock(b);
- return m;
- }
-
-}
-
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.h
deleted file mode 100644
index 0bee9f4be10ef71312e56e89122fc1ef100bca18..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-
-#include <ArmarXCore/libraries/cppgen/CppBlock.h>
-#include <ArmarXCore/libraries/cppgen/CppField.h>
-#include <ArmarXCore/libraries/cppgen/CppCtor.h>
-#include <ArmarXCore/libraries/cppgen/CppMethod.h>
-#include <ArmarXCore/libraries/cppgen/CppClass.h>
-
-#include <memory>
-#include <map>
-#include <string>
-#include <vector>
-
-
-namespace armarx::aron::cppserializer
-{
- class SerializerFactory;
- typedef std::shared_ptr<SerializerFactory> SerializerFactoryPtr;
-
- class Serializer;
- typedef std::shared_ptr<Serializer> SerializerPtr;
-
- class Serializer
- {
- public:
- using PointerType = SerializerPtr;
-
- public:
- // constructors
- Serializer() = default;
- Serializer(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename);
-
- // public member methods
- std::string getCoreCppTypename() const;
- virtual std::string getFullCppTypename() const = 0;
- virtual std::string getFullTypenameGenerator() const = 0;
-
- std::string getAronDataTypename() const;
- std::string getAronDataPtrTypename() const;
-
- std::string getAronTypeTypename() const;
- std::string getAronTypePtrTypename() const;
-
- CppMethodPtr toSpecializedDataWriterMethod(const std::string&, const std::string&, const std::string&, const std::string& enforceType = "") const;
- CppMethodPtr toSpecializedDataReaderMethod(const std::string&, const std::string&, const std::string&, const std::string& enforceType = "") const;
-
- CppMethodPtr toSpecializedTypeWriterMethod(const std::string&, const std::string&, const std::string&, const std::string& enforceType = "") const;
-
- // virtual override definitions
- virtual std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const = 0;
-
- CppCtorPtr toCtor(const std::string&) const;
- virtual std::vector<std::pair<std::string, std::string>> getCtorInitializers(const std::string&) const = 0;
- virtual CppBlockPtr getCtorBlock(const std::string&) const = 0;
-
- CppMethodPtr toResetSoftMethod() const;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const = 0;
-
- CppMethodPtr toWriteTypeMethod() const;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const = 0;
-
- CppMethodPtr toResetHardMethod() const;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const = 0;
-
- CppMethodPtr toWriteMethod() const;
- virtual CppBlockPtr getWriteBlock(const std::string&) const = 0;
-
- CppMethodPtr toReadMethod() const;
- virtual CppBlockPtr getReadBlock(const std::string&) const = 0;
-
- CppMethodPtr toEqualsMethod() const;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const = 0;
-
- // static methods
- static std::string EscapeAccessor(const std::string&);
- static std::string UnescapeAccessor(const std::string&);
-
- static std::string ExtractCppTypename(const typenavigator::NavigatorPtr&);
- static std::vector<std::string> ExtractCppTypenames(const std::vector<typenavigator::NavigatorPtr>&);
-
- static SerializerPtr FromAronTypeNaviagtorPtr(const typenavigator::NavigatorPtr&);
-
- static std::string ResolveMaybeAccessor(const std::string&, const typenavigator::NavigatorPtr&);
- static CppBlockPtr ResolveMaybeWriteBlock(const std::string&, const CppBlockPtr&, const typenavigator::NavigatorPtr&);
- static CppBlockPtr ResolveMaybeReadBlock(const std::string&, const std::string&, const CppBlockPtr&, const typenavigator::NavigatorPtr&, bool enforce_return_type = false);
- static CppBlockPtr ResolveMaybeEqualsBlock(const std::string&, const std::string&, const CppBlockPtr&, const typenavigator::NavigatorPtr&);
- static CppBlockPtr ResolveMaybeResetSoftBlock(const std::string&, const CppBlockPtr&, const typenavigator::NavigatorPtr&);
- static CppBlockPtr ResolveMaybeResetHardBlock(const std::string&, const CppBlockPtr&, const typenavigator::NavigatorPtr&);
-
- protected:
- static const std::string READ_START_RETURN_TYPE_ACCESSOR;
-
- private:
- const static std::string ARON_DATA_NAME;
- const static std::string ARON_DATA_PTR_NAME;
-
- const static std::string ARON_TYPE_NAME;
- const static std::string ARON_TYPE_PTR_NAME;
-
- static const std::map<std::string, std::string> ESCAPE_ACCESSORS;
-
- static const SerializerFactoryPtr FACTORY;
-
- std::string cppTypename;
- std::string aronDataTypename;
- std::string aronTypeTypename;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.cpp
deleted file mode 100644
index 080176c5743b1924313493799227d97a1d4f7714..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// STD/STL
-
-// Header
-#include "SerializerFactory.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/AllSerializers.h>
-
-namespace armarx::aron::cppserializer
-{
- // Access method
- SerializerPtr SerializerFactory::create(const typenavigator::NavigatorPtr& n, const Path& path) const
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- {type::Descriptor::e##upperType, SerializerFactoryPtr(new upperType##SerializerFactory())},
- static const std::map<type::Descriptor, SerializerFactoryPtr> Factories =
- {
- HANDLE_ALL_ARON_TYPES
- };
-#undef RUN_ARON_MACRO
-
- //CheckIfPtrIsNull("NavigatorFactory", "create", path, n);
- auto factory_iterator = Factories.find(n->getDescriptor());
- if (factory_iterator == Factories.end())
- {
- throw error::AronException("NavigatorFactory", "create", "Cannot find the desired factory for input (ice_id): " + n->toAronPtr()->ice_id() + ". Cannot create navigator", path);
- }
- return factory_iterator->second->createSpecific(n, path);
- }
-
- SerializerPtr SerializerFactory::createSpecific(const typenavigator::NavigatorPtr&, const Path&) const
- {
- throw error::AronException("NavigatorFactory", "createSpecific", "Called disallowed method. Use child class instead!");
- }
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- SerializerPtr upperType##SerializerFactory::createSpecific(const typenavigator::NavigatorPtr& n, const Path&) const \
- { \
- typenavigator::upperType##NavigatorPtr casted = typenavigator::upperType##Navigator::DynamicCastAndCheck(n); \
- return SerializerPtr(new serializer::upperType##Serializer(casted)); \
- }
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
deleted file mode 100644
index 5c24d5692f980651a721fe0ffd6cadc54aa327c9..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <unordered_map>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/SerializerFactory.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/AllSerializers.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron::cppserializer
-{
- class SerializerFactory;
- typedef std::shared_ptr<SerializerFactory> SerializerFactoryPtr;
-
- class SerializerFactory :
- virtual public codegenerator::SerializerFactory<typenavigator::NavigatorPtr, SerializerPtr>
- {
- public:
- SerializerFactory() = default;
- virtual SerializerPtr create(const typenavigator::NavigatorPtr&, const Path&) const override;
- virtual SerializerPtr createSpecific(const typenavigator::NavigatorPtr&, const Path&) const override;
-
- };
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##SerializerFactory : \
- virtual public SerializerFactory \
- { \
- public: \
- upperType##SerializerFactory() = default; \
- virtual SerializerPtr createSpecific(const typenavigator::NavigatorPtr&, const Path&) const override; \
- };
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.cpp
deleted file mode 100644
index 4bb11ad7cafabe9d329217cf003c3b7aa82a61bd..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Dict.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- DictSerializer::DictSerializer(const typenavigator::DictNavigatorPtr& e) :
- detail::ContainerSerializerBase<typenavigator::DictNavigator, DictSerializer>(
- "std::map<std::string, " + FromAronTypeNaviagtorPtr(e->getAcceptedType())->getFullCppTypename() + ">",
- simox::meta::get_type_name<data::AronDict>(),
- simox::meta::get_type_name<type::AronDict>(),
- e)
- {
- }
-
- // virtual implementations
- CppBlockPtr DictSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- block_if_data->addLine(accessor + nextEl() + "clear();");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr DictSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr DictSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeStartDict({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
-
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
- CppBlockPtr b2 = type_s->getWriteTypeBlock(type_s->getFullCppTypename());
- b->appendBlock(b2);
- b->addLine("w.writeEndDict(); // of " + accessor);
- return b;
- }
-
- CppBlockPtr DictSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("w.writeStartDict(); // of " + accessor);
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_iterator_key = escaped_accessor + DICT_KEY_ACCESSOR;
- std::string accessor_iterator_val = escaped_accessor + DICT_VALUE_ACCESSOR;
-
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- block_if_data->addLine("for (const auto& [" + accessor_iterator_key + ", " + accessor_iterator_val + "] : " + resolved_accessor + ") ");
-
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
- b2->addLine("w.writeKey(" + accessor_iterator_key + ");");
- b2->appendBlock(type_s->getWriteBlock(accessor_iterator_val));
- block_if_data->addBlock(b2);
- block_if_data->addLine("w.writeEndDict(); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr DictSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_iterator = escaped_accessor + DICT_ITERATOR_ACCESSOR;
- std::string accessor_iterator_key = escaped_accessor + DICT_KEY_ACCESSOR;
-
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
-
- block_if_data->addLine("while(!r.readEndDict()) // of " + accessor);
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
-
- b2->addLine("std::string " + accessor_iterator_key + " = r.readKey(); // in dict " + accessor);
- b2->addLine(type_s->getFullCppTypename() + " " + accessor_iterator + ";");
- b2->appendBlock(type_s->getReadBlock(accessor_iterator));
- b2->addLine(accessor + nextEl() + "insert({" + accessor_iterator_key + ", " + accessor_iterator + "});");
-
- block_if_data->addBlock(b2);
- return ResolveMaybeReadBlock(accessor, "r.readStartDict()", block_if_data, typenavigator);
- }
-
- CppBlockPtr DictSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.h
deleted file mode 100644
index a8f4734f4f5c0f0050dd9758bb9fa6e36637a2a6..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Dict.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class DictSerializer;
- typedef std::shared_ptr<DictSerializer> DictSerializerPtr;
-
- class DictSerializer :
- public detail::ContainerSerializerBase<typenavigator::DictNavigator, DictSerializer>
- {
- public:
- using PointerType = DictSerializerPtr;
-
- public:
- // constructors
- DictSerializer() = delete;
- DictSerializer(const typenavigator::DictNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // Members
- static constexpr const char* DICT_ITERATOR_ACCESSOR = "_iterator";
- static constexpr const char* DICT_KEY_ACCESSOR = "_key";
- static constexpr const char* DICT_VALUE_ACCESSOR = "_value";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.cpp
deleted file mode 100644
index 53e8bbcb28809e8a077e0724b05d26469040e875..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "List.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- ListSerializer::ListSerializer(const typenavigator::ListNavigatorPtr& e) :
- detail::ContainerSerializerBase<typenavigator::ListNavigator, ListSerializer>(
- "std::vector<" + FromAronTypeNaviagtorPtr(e->getAcceptedType())->getFullCppTypename() + ">",
- simox::meta::get_type_name<data::AronList>(),
- simox::meta::get_type_name<type::AronList>(),
- e)
- {
- }
-
- CppBlockPtr ListSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- block_if_data->addLine(accessor + nextEl() + "clear();");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ListSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ListSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
-
- b->addLine("w.writeStartList({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
-
- CppBlockPtr b2 = type_s->getWriteTypeBlock(type_s->getFullCppTypename());
- b->appendBlock(b2);
-
- b->addLine("w.writeEndList(); // of " + accessor);
- return b;
- }
-
- CppBlockPtr ListSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeStartList(); // of " + accessor);
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_iterator = escaped_accessor + LIST_ITERATOR_ACCESSOR;
-
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
- block_if_data->addLine("for(unsigned int " + accessor_iterator + " = 0; " + accessor_iterator + " < " + accessor + nextEl() + "size(); ++" + accessor_iterator + ")");
- block_if_data->addBlock(type_s->getWriteBlock(accessor + nextEl() + "at(" + accessor_iterator + ")"));
- block_if_data->addLine("w.writeEndList(); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ListSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_iterator = escaped_accessor + LIST_ITERATOR_ACCESSOR;
-
- block_if_data->addLine("while(!r.readEndList()) // of " + accessor);
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
-
- auto type_s = FromAronTypeNaviagtorPtr(typenavigator->getAcceptedType());
- b2->addLine(type_s->getFullCppTypename() + " " + accessor_iterator + ";");
- b2->appendBlock(type_s->getReadBlock(accessor_iterator));
- b2->addLine(accessor + nextEl() + "push_back(" + accessor_iterator + ");");
-
- block_if_data->addBlock(b2);
- return ResolveMaybeReadBlock(accessor, "r.readStartList()", block_if_data, typenavigator);
- }
-
- CppBlockPtr ListSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.h
deleted file mode 100644
index 6358a08ce649a5d482d9906af861d1e5bb8841a5..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/List.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/navigator/type/container/List.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class ListSerializer;
- typedef std::shared_ptr<ListSerializer> ListSerializerPtr;
-
- class ListSerializer :
- public detail::ContainerSerializerBase<typenavigator::ListNavigator, ListSerializer>
- {
- public:
- using PointerType = ListSerializerPtr;
-
- public:
- // constructors
- ListSerializer(const typenavigator::ListNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static constexpr const char* LIST_ITERATOR_ACCESSOR = "_iterator";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.cpp
deleted file mode 100644
index 8b2bea70b9cbf9506e59fd3c56f04044400db9c7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Object.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- ObjectSerializer::ObjectSerializer(const typenavigator::ObjectNavigatorPtr& e) :
- detail::ContainerSerializerBase<typenavigator::ObjectNavigator, ObjectSerializer>(
- e->getObjectName(),
- simox::meta::get_type_name<data::AronDict>(),
- simox::meta::get_type_name<type::AronObject>(),
- e)
- {
- }
-
- CppBlockPtr ObjectSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- block_if_data->addLine(accessor + nextEl() + "resetSoft();");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine(accessor + "::writeType(w, " + MAYBE_TO_STRING(typenavigator->getMaybe()) + "); // of " + accessor);
- return b;
- }
-
- CppBlockPtr ObjectSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + nextEl() + "write(w); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + nextEl() + "read(r, true); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartDict()", block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.h
deleted file mode 100644
index 222e37c166b790cc3092a2c8a4fc04f6cd5ec892..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Object.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class ObjectSerializer;
- typedef std::shared_ptr<ObjectSerializer> ObjectSerializerPtr;
-
- class ObjectSerializer :
- public detail::ContainerSerializerBase<typenavigator::ObjectNavigator, ObjectSerializer>
- {
- public:
- using PointerType = ObjectSerializerPtr;
-
- public:
- // constructors
- ObjectSerializer(const typenavigator::ObjectNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static constexpr const char* EXTENDS_ITERATOR_ACCESSOR = "_extends";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.cpp
deleted file mode 100644
index ab4013664318c76526ecbebec1ac4c90ade479a1..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Pair.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- PairSerializer::PairSerializer(const typenavigator::PairNavigatorPtr& e) :
- detail::ContainerSerializerBase<typenavigator::PairNavigator, PairSerializer>(
- "std::pair<" + ExtractCppTypename(e->getFirstAcceptedType()) + ", " + ExtractCppTypename(e->getSecondAcceptedType()) + ">",
- simox::meta::get_type_name<data::AronList>(),
- simox::meta::get_type_name<type::AronPair>(),
- e)
- {
- }
-
- CppBlockPtr PairSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PairSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- auto child_s1 = FromAronTypeNaviagtorPtr(typenavigator->getFirstAcceptedType());
- CppBlockPtr b21 = child_s1->getResetSoftBlock(accessor + nextEl() + "first");
- block_if_data->appendBlock(b21);
-
- auto child_s2 = FromAronTypeNaviagtorPtr(typenavigator->getSecondAcceptedType());
- CppBlockPtr b22 = child_s2->getResetSoftBlock(accessor + nextEl() + "second");
- block_if_data->appendBlock(b22);
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PairSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeStartPair({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
-
- std::string escaped_accessor = EscapeAccessor(accessor);
-
- auto child_s1 = FromAronTypeNaviagtorPtr(typenavigator->getFirstAcceptedType());
- std::string accessor_iterator1 = escaped_accessor + PAIR_FIRST_ACCESSOR;
- b->addLine("w.writeKey(\"0\");");
- CppBlockPtr b21 = child_s1->getWriteTypeBlock(accessor_iterator1);
- b->appendBlock(b21);
-
- auto child_s2 = FromAronTypeNaviagtorPtr(typenavigator->getSecondAcceptedType());
- std::string accessor_iterator2 = escaped_accessor + PAIR_SECOND_ACCESSOR;
- b->addLine("w.writeKey(\"1\");");
- CppBlockPtr b22 = child_s2->getWriteTypeBlock(accessor_iterator2);
- b->appendBlock(b22);
-
- b->addLine("w.writeEndPair(); // of " + accessor);
- return b;
- }
-
- CppBlockPtr PairSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeStartList(); // of " + accessor);
-
- auto child_s1 = FromAronTypeNaviagtorPtr(typenavigator->getFirstAcceptedType());
- CppBlockPtr b21 = child_s1->getWriteBlock(accessor + nextEl() + "first");
- block_if_data->appendBlock(b21);
-
- auto child_s2 = FromAronTypeNaviagtorPtr(typenavigator->getSecondAcceptedType());
- CppBlockPtr b22 = child_s2->getWriteBlock(accessor + nextEl() + "second");
- block_if_data->appendBlock(b22);
-
- block_if_data->addLine("w.writeEndList(); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PairSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- auto child_s1 = FromAronTypeNaviagtorPtr(typenavigator->getFirstAcceptedType());
- CppBlockPtr b21 = child_s1->getReadBlock(accessor + nextEl() + "first");
- block_if_data->appendBlock(b21);
-
- auto child_s2 = FromAronTypeNaviagtorPtr(typenavigator->getSecondAcceptedType());
- CppBlockPtr b22 = child_s2->getReadBlock(accessor + nextEl() + "second");
- block_if_data->appendBlock(b22);
-
- block_if_data->addLine("r.readEndList(); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartList()", block_if_data, typenavigator);
- }
-
- CppBlockPtr PairSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.h
deleted file mode 100644
index fab1eb592ceb5c0f1b373a3170f0908953545be4..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Pair.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Pair.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class PairSerializer;
- typedef std::shared_ptr<PairSerializer> PairSerializerPtr;
-
- class PairSerializer :
- public detail::ContainerSerializerBase<typenavigator::PairNavigator, PairSerializer>
- {
- public:
- using PointerType = PairSerializerPtr;
-
- public:
- // constructors
- PairSerializer(const typenavigator::PairNavigatorPtr& e);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static constexpr const char* PAIR_FIRST_ACCESSOR = "_first";
- static constexpr const char* PAIR_SECOND_ACCESSOR = "_second";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.cpp
deleted file mode 100644
index 188ff3a449994c71109d1fd7f1e213c78c6189f8..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Tuple.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- TupleSerializer::TupleSerializer(const typenavigator::TupleNavigatorPtr& e) :
- detail::ContainerSerializerBase<typenavigator::TupleNavigator, TupleSerializer>(
- "std::tuple<" + simox::alg::join(ExtractCppTypenames(e->getAcceptedTypes()), ", ") + ">",
- simox::meta::get_type_name<data::AronList>(),
- simox::meta::get_type_name<type::AronTuple>(),
- e)
- {
- }
-
- CppBlockPtr TupleSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr TupleSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- unsigned int i = 0;
- for (const auto& child : typenavigator->getAcceptedTypes())
- {
- auto child_s = FromAronTypeNaviagtorPtr(child);
- CppBlockPtr b2 = child_s->getResetSoftBlock("std::get<" + std::to_string(i++) + ">(" + resolved_accessor + ")");
- block_if_data->appendBlock(b2);
- }
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr TupleSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeStartTuple({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- unsigned int i = 0;
- for (const auto& type : typenavigator->getAcceptedTypes())
- {
- std::string accessor_iterator = escaped_accessor + TUPLE_ITERATOR_ACCESSOR + std::to_string(i++);
- auto type_s = FromAronTypeNaviagtorPtr(type);
- b->addLine("w.writeKey(\"" + std::to_string(i) + "\");");
- CppBlockPtr b2 = type_s->getWriteTypeBlock(accessor_iterator);
- b->appendBlock(b2);
- }
- b->addLine("w.writeEndTuple(); // of " + accessor);
- return b;
- }
-
- CppBlockPtr TupleSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeStartList(); // of " + accessor);
-
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- unsigned int i = 0;
- for (const auto& type : typenavigator->getAcceptedTypes())
- {
- auto type_s = FromAronTypeNaviagtorPtr(type);
- CppBlockPtr b2 = type_s->getWriteBlock("std::get<" + std::to_string(i++) + ">(" + resolved_accessor + ")");
- block_if_data->appendBlock(b2);
- }
- block_if_data->addLine("w.writeEndList(); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr TupleSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- unsigned int i = 0;
- for (const auto& type : typenavigator->getAcceptedTypes())
- {
- auto type_s = FromAronTypeNaviagtorPtr(type);
- CppBlockPtr b2 = type_s->getReadBlock("std::get<" + std::to_string(i++) + ">(" + resolved_accessor + ")");
- block_if_data->appendBlock(b2);
- }
- block_if_data->addLine("r.readEndList(); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartList()", block_if_data, typenavigator);
- }
-
- CppBlockPtr TupleSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.h
deleted file mode 100644
index e8039607eedb467608482459770e40a345d74157..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/container/Tuple.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class TupleSerializer;
- typedef std::shared_ptr<TupleSerializer> TupleSerializerPtr;
-
- class TupleSerializer :
- public detail::ContainerSerializerBase<typenavigator::TupleNavigator, TupleSerializer>
- {
- public:
- using PointerType = TupleSerializerPtr;
-
- public:
- // constructors
- TupleSerializer(const typenavigator::TupleNavigatorPtr& e);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static constexpr const char* TUPLE_ITERATOR_ACCESSOR = "_iterator";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h
deleted file mode 100644
index 7acb76328abdc2be4ee0b08577e546900c4e3d46..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include "SerializerBase.h"
-
-
-namespace armarx::aron::cppserializer::detail
-{
- template<typename TypenavigatorT, typename DerivedT>
- class NDArraySerializerBase :
- public SerializerBase<TypenavigatorT, DerivedT>
- {
- public:
-
- NDArraySerializerBase(
- const std::string& cppName,
- const std::string& aronDataTypename,
- const std::string& aronTypeTypename,
- const typename TypenavigatorT::PointerType& t) :
- SerializerBase<TypenavigatorT, DerivedT>(cppName, aronDataTypename, aronTypeTypename, t)
- {}
-
- virtual CppBlockPtr getResetHardBlock(const std::string& accessor) const override
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return this->ResolveMaybeResetHardBlock(accessor, block_if_data, this->typenavigator);
- }
-
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullCppTypename() + "();");
- return this->ResolveMaybeResetSoftBlock(accessor, block_if_data, this->typenavigator);
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h
deleted file mode 100644
index b20979f807c42981c0f9de6bf3106506424f9ea0..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include "SerializerBase.h"
-
-#include <string>
-
-
-namespace armarx::aron::cppserializer::detail
-{
- template<typename TypenavigatorT, typename DerivedT>
- class PrimitiveSerializerBase :
- public SerializerBase<TypenavigatorT, DerivedT>
- {
- public:
- PrimitiveSerializerBase(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename, const typename TypenavigatorT::PointerType& t) :
- SerializerBase<TypenavigatorT, DerivedT>(cppName, aronDataTypename, aronTypeTypename, t)
- {}
-
- virtual CppBlockPtr getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator() + "();");
- return this->ResolveMaybeResetHardBlock(accessor, block_if_data, this->typenavigator);
- }
-
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + this->getFullCppTypename() + "();");
- return this->ResolveMaybeResetSoftBlock(accessor, block_if_data, this->typenavigator);
- }
-
- virtual CppBlockPtr getWriteBlock(const std::string& accessor) const override
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = this->ResolveMaybeAccessor(accessor, this->typenavigator);
- block_if_data->addLine("w.writePrimitive(" + resolved_accessor + "); // of " + accessor);
-
- return this->ResolveMaybeWriteBlock(accessor, block_if_data, this->typenavigator);
- }
-
- virtual CppBlockPtr getReadBlock(const std::string& accessor) const override
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = this->ResolveMaybeAccessor(accessor, this->typenavigator);
- block_if_data->addLine("r.readEndPrimitive(" + resolved_accessor + "); // of " + accessor);
- return this->ResolveMaybeReadBlock(accessor, "r.readStartPrimitive()", block_if_data, this->typenavigator);
- }
-
- virtual CppBlockPtr getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const override
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- block_if_data->addLineAsBlock("return false;");
- return this->ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, this->typenavigator);
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h
deleted file mode 100644
index 92fde748539283fa35cb3ab858155d3e4f88d154..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/Serializer.h>
-
-#include <memory>
-#include <string>
-
-
-namespace armarx::aron::cppserializer::detail
-{
- template<typename TypenavigatorT, typename DerivedT>
- class SerializerBase :
- public cppserializer::Serializer
- {
- public:
- using PointerType = std::shared_ptr<DerivedT>;
- using TypenavigatorType = TypenavigatorT;
-
- public:
- SerializerBase(
- const std::string& cppName,
- const std::string& aronDataTypename,
- const std::string& aronTypeTypename,
- const typename TypenavigatorType::PointerType& t) :
- Serializer(cppName, aronDataTypename, aronTypeTypename),
- typenavigator(t)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- virtual std::string getFullCppTypename() const override
- {
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- return getCoreCppTypename();
- case type::Maybe::eOptional:
- return "std::optional<" + getCoreCppTypename() + ">";
- case type::Maybe::eRawPointer:
- return getCoreCppTypename() + "*";
- case type::Maybe::eSharedPointer:
- return "std::shared_ptr<" + getCoreCppTypename() + ">";
- case type::Maybe::eUniquePointer:
- return "std::unique_ptr<" + getCoreCppTypename() + ">";
- default:
- throw error::MaybeNotValidException("SerializerBase", "getFullCppTypename", "Received unknown maybe enum", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- virtual std::string getFullTypenameGenerator() const override
- {
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- return getCoreCppTypename();
- case type::Maybe::eOptional:
- return "std::make_optional<" + getCoreCppTypename() + ">";
- case type::Maybe::eRawPointer:
- return "new " + getCoreCppTypename();
- case type::Maybe::eSharedPointer:
- return "std::make_shared<" + getCoreCppTypename() + ">";
- case type::Maybe::eUniquePointer:
- return "std::make_unique<" + getCoreCppTypename() + ">";
- default:
- throw error::MaybeNotValidException("SerializerBase", "getFullTypenameGenerator", "Received unknown maybe enum", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- virtual std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string& name) const override
- {
- CppFieldPtr field = CppFieldPtr(new CppField(this->getFullCppTypename(), name));
- return {field};
- }
-
- virtual std::vector<std::pair<std::string, std::string>> getCtorInitializers(const std::string&) const override
- {
- return {};
- }
-
- virtual CppBlockPtr getCtorBlock(const std::string&) const override
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- return b;
- }
-
-
- protected:
- std::string nextEl() const
- {
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eNone:
- return ".";
- case type::Maybe::eOptional:
- case type::Maybe::eRawPointer:
- case type::Maybe::eSharedPointer:
- case type::Maybe::eUniquePointer:
- return "->";
- default:
- throw error::MaybeNotValidException("SerializerBase", "nextEl", "Received unknown maybe enum", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- std::string toPointerAccessor(const std::string& accessor) const
- {
- switch (typenavigator->getMaybe())
- {
- case type::Maybe::eRawPointer:
- return accessor;
- case type::Maybe::eSharedPointer:
- case type::Maybe::eUniquePointer:
- return accessor + ".get()";
- default:
- throw error::MaybeNotValidException("SerializerBase", "toPointerAccessor", "Received invalid maybe enum (not a pointer?)", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- protected:
- typename TypenavigatorT::PointerType typenavigator;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.cpp
deleted file mode 100644
index dc00ff9b0271b310b91be4656721eb6ed98039b1..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "IntEnum.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- IntEnumSerializer::IntEnumSerializer(const typenavigator::IntEnumNavigatorPtr& e) :
- detail::SerializerBase<typenavigator::IntEnumNavigator, IntEnumSerializer>(
- e->getEnumName(),
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronIntEnum>(),
- e)
- {
- }
-
- CppBlockPtr IntEnumSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
-
- block_if_data->addLine(accessor + nextEl() + "resetSoft();");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr IntEnumSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine(accessor + "::writeType(w, " + MAYBE_TO_STRING(typenavigator->getMaybe()) + ");");
- return b;
- }
-
- CppBlockPtr IntEnumSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- if (typenavigator->getMaybe() != type::Maybe::eNone)
- {
- b->addLine(accessor + " = {};");
- }
- else
- {
- b->addLine(accessor + nextEl() + "resetHard();");
- }
- return b;
- }
-
- CppBlockPtr IntEnumSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + nextEl() + "write(w);");
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr IntEnumSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine(accessor + nextEl() + "read(r);");
- return b;
- }
-
- CppBlockPtr IntEnumSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("if (not (" + accessor + " == " + otherInstanceAccessor + "))");
- b->addLineAsBlock("return false;");
- return b;
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.h
deleted file mode 100644
index ce5feac09dcd1c2d802b176cb2d553d48adf7170..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/enum/IntEnum.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h>
-
-#include <map>
-#include <string>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class IntEnumSerializer;
- typedef std::shared_ptr<IntEnumSerializer> IntEnumSerializerPtr;
-
- class IntEnumSerializer :
- virtual public detail::SerializerBase<typenavigator::IntEnumNavigator, IntEnumSerializer>
- {
- public:
- using PointerType = IntEnumSerializerPtr;
-
- public:
- // constructors
- IntEnumSerializer(const typenavigator::IntEnumNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // Members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.cpp
deleted file mode 100644
index 54a4668819869c3305d79a98531cd8cdd348bf14..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "EigenMatrix.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<std::string, std::pair<std::string, int>> EigenMatrixSerializer::ACCEPTED_TYPES =
- {
- {"short", {"short", 2}},
- {"int", {"int", 4}},
- {"long", {"long", 8}},
- {"float", {"float", 4}},
- {"double", {"double", 8}},
- //{"complex float", {"std::complex<float>", ???}},
- //{"complex double", {"std::complex<double>", ???}}
- };
-
- // constructors
- EigenMatrixSerializer::EigenMatrixSerializer(const typenavigator::EigenMatrixNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::EigenMatrixNavigator, EigenMatrixSerializer>(
- "Eigen::Matrix<" + ACCEPTED_TYPES.at(n->getTypename()).first + ", " + std::to_string(n->getRows()) + ", " + std::to_string(n->getCols()) + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronEigenMatrix>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr EigenMatrixSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
- block->addLine(accessor + ".setZero();");
- return this->ResolveMaybeResetHardBlock(accessor, block, this->typenavigator);
- }
-
- CppBlockPtr EigenMatrixSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- return getResetHardBlock(accessor);
- }
-
- CppBlockPtr EigenMatrixSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeEigenMatrix({(int) " + std::to_string(typenavigator->getRows()) + ", (int) " + std::to_string(typenavigator->getCols()) + ", \"" + typenavigator->getTypename() + "\", " + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr EigenMatrixSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeNDArray({(int) " + accessor + nextEl() + "rows(), (int) " + accessor + nextEl() + "cols(), " + std::to_string(ACCEPTED_TYPES.at(typenavigator->getTypename()).second) + "}, \"" + typenavigator->getTypename() + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr EigenMatrixSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator);
- }
-
- CppBlockPtr EigenMatrixSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + ResolveMaybeAccessor(otherInstanceAccessor, typenavigator) + ")))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.h
deleted file mode 100644
index 1885efb76b1b53ab533d83fd4b071592fa040aeb..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenMatrix.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h>
-
-#include <map>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class EigenMatrixSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::EigenMatrixNavigator, EigenMatrixSerializer>
- {
- public:
- // constructors
- EigenMatrixSerializer(const typenavigator::EigenMatrixNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // Members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.cpp
deleted file mode 100644
index 41e3faf1bd3797cc721b27bfa49e0b70740c76b2..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "EigenQuaternion.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<std::string, std::pair<std::string, int>> EigenQuaternionSerializer::ACCEPTED_TYPES =
- {
- {"float", {"float", 4}},
- {"double", {"double", 8}}
- };
-
- // constructors
- EigenQuaternionSerializer::EigenQuaternionSerializer(const typenavigator::EigenQuaternionNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::EigenQuaternionNavigator, EigenQuaternionSerializer>(
- "Eigen::Quaternion<" + ACCEPTED_TYPES.at(n->getTypename()).first + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronEigenQuaternion>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr EigenQuaternionSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
- block->addLine(accessor + ".setIdentity();");
- return this->ResolveMaybeResetHardBlock(accessor, block, this->typenavigator);
- }
-
- CppBlockPtr EigenQuaternionSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- return getResetHardBlock(accessor);
- }
-
- CppBlockPtr EigenQuaternionSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeEigenQuaternion({\"" + typenavigator->getTypename() + "\", " + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr EigenQuaternionSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeNDArray({" + simox::alg::to_string(typenavigator->ACCEPTED_DIMENSION, ", ") + ", " + std::to_string(ACCEPTED_TYPES.at(typenavigator->getTypename()).second) + "}, \"" + typenavigator->getTypename() + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "coeffs().data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr EigenQuaternionSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "coeffs().data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator);
- }
-
- CppBlockPtr EigenQuaternionSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.h
deleted file mode 100644
index 8f471d8f3e2570d51fac512d14b1b06bbbed692d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/EigenQuaternion.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h>
-
-#include <map>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class EigenQuaternionSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::EigenQuaternionNavigator, EigenQuaternionSerializer>
- {
- public:
- using PointerType = std::shared_ptr<EigenQuaternionSerializer>;
-
- public:
- // constructors
- EigenQuaternionSerializer(const typenavigator::EigenQuaternionNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // Members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.cpp
deleted file mode 100644
index 94e7bfe85af077cfaa9c69aa5b8a51869f7b5c60..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "IVTCByteImage.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<std::string, std::pair<std::string, int>> IVTCByteImageSerializer::ACCEPTED_TYPES =
- {
- {"GrayScale", {"CByteImage::ImageType::eGrayScale", 1}},
- {"RGB24", {"CByteImage::ImageType::eRGB24", 3}},
- {"RGB24Split", {"CByteImage::ImageType::eRGB24Split", 3}}
- };
-
- // constructors
- IVTCByteImageSerializer::IVTCByteImageSerializer(const typenavigator::IVTCByteImageNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::IVTCByteImageNavigator, IVTCByteImageSerializer>(
- "CByteImage",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronIVTCByteImage>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- if (typenavigator->getMaybe() == type::Maybe::eNone or typenavigator->getMaybe() == type::Maybe::eOptional)
- {
- throw error::MaybeNotValidException("IVTCByteImageSerializer", "IVTCByteImageSerializer", "An IVTCByteImage must be a pointer!", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- CppBlockPtr IVTCByteImageSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + nextEl() + "Set(" + accessor + nextEl() + "width, " + accessor + nextEl() + "height, " + accessor + nextEl() + "type);");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr IVTCByteImageSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeIVTCByteImage({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr IVTCByteImageSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeNDArray({" + accessor + nextEl() + "width, " + accessor + nextEl() + "height, " + accessor + nextEl() + "bytesPerPixel}, std::to_string(" + accessor + nextEl() + "type), reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "pixels)); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr IVTCByteImageSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string read_start_result_accessor = escaped_accessor + READ_START_RETURN_TYPE_ACCESSOR;
-
- block_if_data->addLine(accessor + nextEl() + "Set(" + read_start_result_accessor + ".dims[0], " + read_start_result_accessor + ".dims[1], static_cast<CByteImage::ImageType>(std::stoi(" + read_start_result_accessor + ".type)));");
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "pixels)); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator, true);
- }
-
- CppBlockPtr IVTCByteImageSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (not (" + accessor + nextEl() + "IsCompatible(" + toPointerAccessor(otherInstanceAccessor) + ")))");
- block_if_data->addLineAsBlock("return false;");
- block_if_data->addLine("if (not (memcmp(" + accessor + nextEl() + "pixels, " + otherInstanceAccessor + nextEl() + "pixels, " + accessor + nextEl() + "width * " + accessor + nextEl() + "height * " + accessor + nextEl() + "bytesPerPixel) == 0))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.h
deleted file mode 100644
index 3e978ca5f69441e960e2b221f3a06779d0f1d7b7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/IVTCByteImage.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.h>
-
-#include <map>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class IVTCByteImageSerializer;
- typedef std::shared_ptr<IVTCByteImageSerializer> AronIVTCByteImageTypeCppSerializerPtr;
-
- class IVTCByteImageSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::IVTCByteImageNavigator, IVTCByteImageSerializer>
- {
- public:
- using PointerType = AronIVTCByteImageTypeCppSerializerPtr;
-
- public:
- // constructors
- IVTCByteImageSerializer(const typenavigator::IVTCByteImageNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.cpp
deleted file mode 100644
index 771ffb4f301fb705b19474f5a9c28ef8da5e3395..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Image.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<typenavigator::ImagePixelType, std::string>
- ImageSerializer::pixelTypeMap =
- {
- { typenavigator::ImagePixelType::Rgb24, "CV_8UC3" },
- { typenavigator::ImagePixelType::Depth32, "CV_32FC1"},
- };
-
-
- // constructors
- ImageSerializer::ImageSerializer(const typenavigator::ImageNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::ImageNavigator, ImageSerializer>(
- "cv::Mat",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronImage>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
-
- CppBlockPtr ImageSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
-
- std::string typeConstant;
- {
- if (auto it = pixelTypeMap.find(typenavigator->getPixelType()); it != pixelTypeMap.end())
- {
- typeConstant = it->second;
- }
- else
- {
- std::stringstream ss;
- ss << "Pixel type '" << static_cast<int>(typenavigator->getPixelType()) << "' "
- << "is not mapped to an OpenCV pixel type.";
- throw error::AronException("ImageSerializer", __FUNCTION__, ss.str());
- }
- }
-
- block_if_data->addLine(accessor + ".create(0, 0, " + typeConstant + ");");
- return this->ResolveMaybeResetHardBlock(accessor, block_if_data, this->typenavigator);
- }
-
-
- CppBlockPtr ImageSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
-
- block_if_data->addLine(accessor + " = 0;");
-
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
-
- CppBlockPtr ImageSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
-
- std::string typeName;
- switch (typenavigator->getPixelType())
- {
-#define CASE( typeConstant ) \
-case typeConstant : \
- typeName = "::armarx::aron::typenavigator::ImageNavigator::pixelTypeToName( " #typeConstant " )"; \
- break;
-
- CASE(::armarx::aron::typenavigator::ImagePixelType::Rgb24)
- CASE(::armarx::aron::typenavigator::ImagePixelType::Depth32)
-
-#undef CASE
- }
-
- b->addLine("w.writeImage({" + typeName + ", " + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
-
- CppBlockPtr ImageSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_shape = "shape";
-
- block->addLine("std::vector<int> " + accessor_shape + "(" + accessor + ".size.p, " + accessor + ".size.p + " + accessor + ".dims);");
- block->addLine(accessor_shape + ".push_back(" + accessor + nextEl() + "elemSize());");
-
-
-#if 0 // Target code:
- std::string type;
- switch (the_depth32_image.type())
- {
- case CV_8UC3:
- type = ::armarx::aron::typenavigator::ImageNavigator::pixelTypeToName(::armarx::aron::typenavigator::ImagePixelType::RGB24);
- break;
- case CV_32FC1:
- type = ::armarx::aron::typenavigator::ImageNavigator::pixelTypeToName(::armarx::aron::typenavigator::ImagePixelType::DEPTH32);
- break;
- default:
- {
- std::stringstream ss;
- ss << "OpenCV image type " << the_depth32_image.type() << " cannot be serialized.";
- throw ::armarx::aron::error::AronException("ImageTest", __FUNCTION__, ss.str());
- }
- }
-#endif
-
- block->addLine("std::string arrayType;");
- block->addLine("switch (" + accessor + ".type())");
- {
- CppBlockPtr block_switch = std::make_shared<CppBlock>();
-
-#define CASE( typeConstant ) \
- block_switch->addLine("case " + pixelTypeMap.at(typeConstant) + ":"); \
- block_switch->addLine("arrayType = ::armarx::aron::typenavigator::ImageNavigator::pixelTypeToName(" #typeConstant ");"); \
- block_switch->addLine("break;")
-
- CASE(::armarx::aron::typenavigator::ImagePixelType::Rgb24);
- CASE(::armarx::aron::typenavigator::ImagePixelType::Depth32);
-
-#undef CASE
-
- block_switch->addLine("default:");
- {
- CppBlockPtr block_default = std::make_shared<CppBlock>();
- block_default->addLine("std::stringstream ss;");
- block_default->addLine("ss << \"OpenCV image type \" << " + accessor + ".type() << \" cannot be serialized.\";");
- block_default->addLine("throw ::armarx::aron::error::AronException(\"" + typenavigator->getName() + "\", __FUNCTION__, ss.str());");
-
- block_switch->addBlock(block_default);
- }
- block->addBlock(block_switch);
- }
-
-
- block->addLine("w.writeNDArray(" + accessor_shape + ", arrayType, reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "data)); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block, typenavigator);
- }
-
-
- CppBlockPtr ImageSerializer::getReadBlock(const std::string& accessor) const
- {
- const std::string escaped_accessor = EscapeAccessor(accessor);
- const std::string read_start_result_accessor = escaped_accessor + READ_START_RETURN_TYPE_ACCESSOR;
-
-#if 0 // Target code
- auto the_rgb24_image_return_type = r.readStartNDArray(); // of the_rgb24_image
-
- if (!the_rgb24_image_return_type.dims.empty())
- {
- std::vector<int> shape{the_rgb24_image_return_type.dims.begin(), std::prev(the_rgb24_image_return_type.dims.end())};
-
- ::armarx::aron::typenavigator::ImagePixelType pixelType = ::armarx::aron::typenavigator::ImageNavigator::pixelTypeFromName(the_rgb24_image_return_type.type);
- int cvMatType = 0;
- switch (pixelType)
- {
- case ::armarx::aron::typenavigator::ImagePixelType::RGB24:
- cvMatType = CV_8UC3;
- case ::armarx::aron::typenavigator::ImagePixelType::DEPTH32:
- cvMatType = CV_32FC1;
- default:
- {
- std::stringstream ss;
- ss << "NDArray Type '" << the_rgb24_image_return_type.type << "' cannot be deserialized as image.";
- throw ::armarx::aron::error::AronException("AronImageType", __FUNCTION__, ss.str());
- }
- }
-
- the_rgb24_image.create(shape, cvMatType);
- r.readEndNDArray(reinterpret_cast<unsigned char*>(the_rgb24_image.data)); // of the_rgb24_image
- }
-#endif
-
- CppBlockPtr block = std::make_shared<CppBlock>();
-
- block->addLine("if (!" + read_start_result_accessor + ".dims.empty())");
- {
- CppBlockPtr block_if = std::make_shared<CppBlock>();
-
- block_if->addLine("std::vector<int> shape{" + read_start_result_accessor + ".dims.begin(), std::prev(" + read_start_result_accessor + ".dims.end())};");
-
- block_if->addLine("::armarx::aron::typenavigator::ImagePixelType pixelType = ::armarx::aron::typenavigator::ImageNavigator::pixelTypeFromName(" + read_start_result_accessor + ".type);");
- block_if->addLine("int cvMatType = 0;");
- block_if->addLine("switch (pixelType)");
- {
- CppBlockPtr block_switch = std::make_shared<CppBlock>();
-
-#define CASE( typeConstant ) \
- block_switch->addLine("case " #typeConstant ":"); \
- block_switch->addLine("cvMatType = " + pixelTypeMap.at(typeConstant) + ";"); \
- block_switch->addLine("break;")
-
- CASE(::armarx::aron::typenavigator::ImagePixelType::Rgb24);
- CASE(::armarx::aron::typenavigator::ImagePixelType::Depth32);
-
-#undef CASE
-
- block_switch->addLine("default:");
- {
- CppBlockPtr block_default = std::make_shared<CppBlock>();
- block_default->addLine("std::stringstream ss;");
- block_default->addLine("ss << \"NdArray Type '\" << " + read_start_result_accessor + ".type << \"' cannot be deserialized as image.\";");
- block_default->addLine("throw ::armarx::aron::error::AronException(\"AronImageType\", __FUNCTION__, ss.str());");
-
- block_switch->addBlock(block_default);
- }
- block_if->addBlock(block_switch);
- }
-
- block_if->addLine(accessor + ".create(shape, cvMatType);");
- block_if->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "data)); // of " + accessor);
- block->addBlock(block_if);
- }
-
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block, typenavigator, true);
- }
-
-
- CppBlockPtr ImageSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("if (cv::countNonZero(" + accessor + " != " + otherInstanceAccessor + ") != 0)");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.h
deleted file mode 100644
index a44cafbe199c352576c1307d6cdcd20debb3f871..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Image.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.h>
-
-#include <map>
-#include <memory>
-#include <string>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class ImageSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::ImageNavigator, ImageSerializer>
- {
- public:
- using PointerType = std::shared_ptr<ImageSerializer>;
-
- public:
-
- ImageSerializer(const typenavigator::ImageNavigatorPtr& n);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
-
- private:
-
- static constexpr const char* ITERATOR_ACCESSOR = "_iterator";
- static constexpr const char* SHAPE_ACCESSOR = "_shape";
- static constexpr const char* NDIM_ACCESSOR = "_ndim";
-
- /// Maps ARON pixel types to OpenCV image type constants.
- static const std::map<typenavigator::ImagePixelType, std::string> pixelTypeMap;
-
- };
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.h
deleted file mode 100644
index 6e6a72f01b84db55c6b059a74c16eb59aaa27b2d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.h>
-
-#include <string>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class NDArraySerializer;
- typedef std::shared_ptr<NDArraySerializer> AronNDArrayTypeCppSerializerPtr;
-
- class NDArraySerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::NDArrayNavigator, NDArraySerializer>
- {
- public:
- using PointerType = AronNDArrayTypeCppSerializerPtr;
-
- public:
- // constructors
- NDArraySerializer(const typenavigator::NDArrayNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- static constexpr const char* DIMENSION_ACCESSOR = "_dimensions";
- static constexpr const char* TYPE_ACCESSOR = "_type";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.cpp
deleted file mode 100644
index 0528b58b4efd7a05484c376c6dc85d722f536459..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "OpenCVMat.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<std::string, std::pair<std::string, int>> OpenCVMatSerializer::ACCEPTED_TYPES =
- {
- { "8u", {"CV_8U", 1}},
- { "8s", {"CV_8S", 1}},
- {"16u", {"CV_16U", 2}},
- {"16s", {"CV_16S", 2}},
- {"32s", {"CV_32S", 4}},
- {"32f", {"CV_32F", 4}},
- {"64f", {"CV_64F", 8}},
- };
-
- // constructors
- OpenCVMatSerializer::OpenCVMatSerializer(const typenavigator::OpenCVMatNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::OpenCVMatNavigator, OpenCVMatSerializer>(
- "cv::Mat",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronOpenCVMat>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- std::pair<CppBlockPtr, std::string> OpenCVMatSerializer::getShapeFromAccessor(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
-
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string accessor_shape = escaped_accessor + SHAPE_ACCESSOR;
- std::string accessor_iterator = escaped_accessor + ITERATOR_ACCESSOR;
-
- b->addLine("std::vector<int> " + accessor_shape + ";");
- b->addLine("for (int " + accessor_iterator + " = 0; " + accessor_iterator + " < " + accessor + nextEl() + "dims; ++" + accessor_iterator + ")");
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
- b2->addLine(accessor_shape + ".push_back(" + accessor + nextEl() + "size[" + accessor_iterator + "]);");
- b->addBlock(b2);
- return {b, accessor_shape};
- }
-
-
- CppBlockPtr OpenCVMatSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- std::string sizes;
- {
- const std::vector<int> shape = typenavigator->getShape();
- sizes = simox::alg::join(simox::alg::multi_to_string(shape), ", ");
- sizes = "std::vector<int>{ " + sizes + " }";
- }
- std::string type = typenavigator->getTypeName();
- {
- type = simox::alg::to_lower(type);
- type = simox::alg::remove_prefix(type, "cv_");
- if (auto it = ACCEPTED_TYPES.find(type); it != ACCEPTED_TYPES.end())
- {
- type = it->second.first;
- }
- }
-
- block_if_data->addLine(accessor + " = " + this->getFullTypenameGenerator()
- + "(" + sizes + ", " + type + ");");
- return this->ResolveMaybeResetHardBlock(accessor, block_if_data, this->typenavigator);
- }
-
-
- CppBlockPtr OpenCVMatSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- auto [get_dim_block, accessor_shape] = getShapeFromAccessor(accessor);
- block_if_data->appendBlock(get_dim_block);
- block_if_data->addLine("if (!" + accessor_shape + ".empty())");
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
- b2->addLine(accessor + " = " + getFullCppTypename() + "(" + accessor_shape + ", " + accessor + nextEl() + "type());");
- block_if_data->addBlock(b2);
-
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr OpenCVMatSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeOpenCVMat({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr OpenCVMatSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- std::string escaped_accessor = EscapeAccessor(accessor);
-
- auto [get_dim_block, accessor_shape] = getShapeFromAccessor(accessor);
- block_if_data->appendBlock(get_dim_block);
- block_if_data->addLine(accessor_shape + ".push_back(" + accessor + nextEl() + "elemSize());");
- block_if_data->addLine("w.writeNDArray(" + accessor_shape + ", std::to_string(" + accessor + nextEl() + "type()), reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "data)); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr OpenCVMatSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string read_start_result_accessor = escaped_accessor + READ_START_RETURN_TYPE_ACCESSOR;
-
- block_if_data->addLine("if (!" + read_start_result_accessor + ".dims.empty())");
- CppBlockPtr b2 = CppBlockPtr(new CppBlock());
- b2->addLine(accessor + " = " + getCoreCppTypename() + "(std::vector<int>({" + read_start_result_accessor + ".dims.begin(), std::prev(" + read_start_result_accessor + ".dims.end())}), std::stoi(" + read_start_result_accessor + ".type));");
- b2->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "data)); // of " + accessor);
- block_if_data->addBlock(b2);
-
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator, true);
- }
-
- CppBlockPtr OpenCVMatSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (cv::countNonZero(" + accessor + " != " + otherInstanceAccessor + ") != 0)");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.h
deleted file mode 100644
index 08aacde0f0d11e47cd8cca3ae17057928bf2daf3..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/OpenCVMat.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <utility> // std::pair
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class OpenCVMatSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::OpenCVMatNavigator, OpenCVMatSerializer>
- {
- public:
- using PointerType = std::shared_ptr<OpenCVMatSerializer>;
-
- public:
- // constructors
- OpenCVMatSerializer(const typenavigator::OpenCVMatNavigatorPtr& n);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- std::pair<CppBlockPtr, std::string> getShapeFromAccessor(const std::string& accessor) const;
-
- private:
- // members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- static constexpr const char* ITERATOR_ACCESSOR = "_iterator";
- static constexpr const char* SHAPE_ACCESSOR = "_shape";
- static constexpr const char* NDIM_ACCESSOR = "_ndim";
- };
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.cpp
deleted file mode 100644
index 1bd39c73c977b6cf4da7a7de01b3346083c7c742..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Orientation.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- OrientationSerializer::OrientationSerializer(const typenavigator::OrientationNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::OrientationNavigator, OrientationSerializer>(
- "Eigen::Quaternion<" + n->ACCEPTED_TYPE + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronOrientation>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr OrientationSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
- block->addLine(accessor + ".setIdentity();");
- return this->ResolveMaybeResetHardBlock(accessor, block, this->typenavigator);
- }
-
- CppBlockPtr OrientationSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- return getResetHardBlock(accessor);
- }
-
- CppBlockPtr OrientationSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
- b->addLine("w.writeOrientation({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr OrientationSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("w.writeNDArray({" + simox::alg::to_string(typenavigator->ACCEPTED_DIMENSION, ", ") + ", 4}, \"" + typenavigator->ACCEPTED_TYPE + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "coeffs().data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr OrientationSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "coeffs().data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator);
- }
-
- CppBlockPtr OrientationSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.h
deleted file mode 100644
index b4851e4bc6806fc60b157302a7bfc53adc6a110a..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Orientation.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class OrientationSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::OrientationNavigator, OrientationSerializer>
- {
- public:
- using PointerType = std::shared_ptr<class OrientationSerializer>;
-
- public:
-
- // constructors
- OrientationSerializer(const typenavigator::OrientationNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- };
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.cpp
deleted file mode 100644
index 2e0234f3aff59d141988304448c128717bd9476d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PCLPointCloud.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- const std::map<std::string, std::pair<std::string, int>> PCLPointCloudSerializer::ACCEPTED_TYPES =
- {
- // see http://docs.ros.org/en/groovy/api/pcl/html/point__types_8hpp_source.html
- {"PointXYZ", {"pcl::PointXYZ", 16}},
- {"PointXYZI", {"pcl::PointXYZI", 32}},
- {"PointXYZL", {"pcl::PointXYZL", 32}},
- {"PointXYZRGB", {"pcl::PointXYZRGB", 32}},
- {"PointXYZRGBL", {"pcl::PointXYZRGBL", 32}},
- {"PointXYZRGBA", {"pcl::PointXYZRGBA", 32}},
- {"PointXYZHSV", {"pcl::PointXYZHSV", 32}}
- };
-
- // constructors
- PCLPointCloudSerializer::PCLPointCloudSerializer(const typenavigator::PCLPointCloudNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::PCLPointCloudNavigator, PCLPointCloudSerializer>(
- "pcl::PointCloud<" + ACCEPTED_TYPES.at(n->getTypename()).first + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronPCLPointCloud>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr PCLPointCloudSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine(accessor + " = " + getFullCppTypename() + "(" + accessor + nextEl() + "width, " + accessor + nextEl() + "height);");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PCLPointCloudSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writePCLPointCloud({\"" + typenavigator->getTypename() + "\", " + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr PCLPointCloudSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writeNDArray({" + accessor + nextEl() + "width, " + accessor + nextEl() + "height, " + std::to_string(ACCEPTED_TYPES.at(typenavigator->getTypename()).second) + "}, \"" + typenavigator->getTypename() + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "points.data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PCLPointCloudSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string read_start_result_accessor = escaped_accessor + READ_START_RETURN_TYPE_ACCESSOR;
-
- block_if_data->addLine(accessor + " = " + getCoreCppTypename() + "(" + read_start_result_accessor + ".dims[0], " + read_start_result_accessor + ".dims[1]);");
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "points.data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator, true);
- }
-
- CppBlockPtr PCLPointCloudSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("if (" + accessor + nextEl() + "width != " + otherInstanceAccessor + nextEl() + "width || " + accessor + nextEl() + "height != " + otherInstanceAccessor + nextEl() + "height)");
- block_if_data->addLineAsBlock("return false;");
-
- //block_if_data->addLine("if (" + accessor + nextEl() + "points != " + otherInstanceAccessor + nextEl() + "points)");
- //block_if_data->addLine("\t return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.h
deleted file mode 100644
index a0692c64ef06e92875ad66079f871fecc211d0fe..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/PCLPointCloud.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.h>
-
-#include <map>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class PCLPointCloudSerializer;
- typedef std::shared_ptr<PCLPointCloudSerializer> AronPCLPointCloudTypeCppSerializerPtr;
-
- class PCLPointCloudSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::PCLPointCloudNavigator, PCLPointCloudSerializer>
- {
- public:
- using PointerType = AronPCLPointCloudTypeCppSerializerPtr;
-
- public:
- // constructors
- PCLPointCloudSerializer(const typenavigator::PCLPointCloudNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetSoftBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.cpp
deleted file mode 100644
index b6be09e9f94b972f23e226a6dc8cbd64e11c6040..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Pose.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- PoseSerializer::PoseSerializer(const typenavigator::PoseNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::PoseNavigator, PoseSerializer>(
- "Eigen::Matrix<" + n->ACCEPTED_TYPE + ", " + simox::alg::to_string(n->ACCEPTED_DIMENSION, ", ") + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronPose>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr PoseSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
- block->addLine(accessor + ".setIdentity();");
- return this->ResolveMaybeResetHardBlock(accessor, block, this->typenavigator);
- }
-
- CppBlockPtr PoseSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- return getResetHardBlock(accessor);
- }
-
- CppBlockPtr PoseSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
- b->addLine("w.writePose({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr PoseSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("w.writeNDArray({" + simox::alg::to_string(typenavigator->ACCEPTED_DIMENSION, ", ") + ", 4}, \"" + typenavigator->ACCEPTED_TYPE + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PoseSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator);
- }
-
- CppBlockPtr PoseSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.h
deleted file mode 100644
index 195a04015ea58ae14b419dcda0bf163981cecff6..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Pose.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class PoseSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::PoseNavigator, PoseSerializer>
- {
- public:
- using PointerType = std::shared_ptr<PoseSerializer>;
-
- public:
- // constructors
- PoseSerializer(const typenavigator::PoseNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.cpp
deleted file mode 100644
index 6c9e54ecd0a074cc1c56a63f090fc56c06152004..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Position.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- PositionSerializer::PositionSerializer(const typenavigator::PositionNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::PositionNavigator, PositionSerializer>(
- "Eigen::Matrix<" + n->ACCEPTED_TYPE + ", " + simox::alg::to_string(n->ACCEPTED_DIMENSION, ", ") + ">",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronPosition>(),
- n)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- CppBlockPtr PositionSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block = std::make_shared<CppBlock>();
- block->addLine(accessor + ".setZero();");
- return this->ResolveMaybeResetHardBlock(accessor, block, this->typenavigator);
- }
-
- CppBlockPtr PositionSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- return getResetHardBlock(accessor);
- }
-
- CppBlockPtr PositionSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = std::make_shared<CppBlock>();
- b->addLine("w.writePosition({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr PositionSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("w.writeNDArray({" + simox::alg::to_string(typenavigator->ACCEPTED_DIMENSION, ", ") + ", 4}, \"" + typenavigator->ACCEPTED_TYPE + "\", reinterpret_cast<const unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
-
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr PositionSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("r.readEndNDArray(reinterpret_cast<unsigned char*>(" + accessor + nextEl() + "data())); // of " + accessor);
- return ResolveMaybeReadBlock(accessor, "r.readStartNDArray()", block_if_data, typenavigator);
- }
-
- CppBlockPtr PositionSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = std::make_shared<CppBlock>();
- block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
- block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.h
deleted file mode 100644
index 61026f4617401bdc64393c4e813c3fd535dce301..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/Position.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class PositionSerializer :
- virtual public detail::NDArraySerializerBase<typenavigator::PositionNavigator, PositionSerializer>
- {
- public:
- using PointerType = std::shared_ptr<PositionSerializer>;
-
- public:
- // constructors
- PositionSerializer(const typenavigator::PositionNavigatorPtr&);
-
- // virtual implementations
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.h
deleted file mode 100644
index 688aeb2d365a5e785e575050f8e01983b3211e9e..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class BoolSerializer;
- typedef std::shared_ptr<BoolSerializer> BoolSerializerPtr;
-
- class BoolSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::BoolNavigator, BoolSerializer>
- {
- public:
- /* constructors */
- BoolSerializer(const typenavigator::BoolNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.h
deleted file mode 100644
index 835ebc61264b9dbb636e12a9469a0deff0bf1e90..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Float.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class FloatSerializer;
- typedef std::shared_ptr<FloatSerializer> FloatSerializerPtr;
-
- class FloatSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::FloatNavigator, FloatSerializer>
- {
- public:
- /* constructors */
- FloatSerializer(const typenavigator::FloatNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.h
deleted file mode 100644
index 6d26dc8e63f6372a2e0210816f9addb394af0294..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Int.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class IntSerializer;
- typedef std::shared_ptr<IntSerializer> IntSerializerPtr;
-
- class IntSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::IntNavigator, IntSerializer>
- {
- public:
- /* constructors */
- IntSerializer(const typenavigator::IntNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.h
deleted file mode 100644
index 227c91bfded830f5744c35ddd3ab39ad79897775..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Long.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class LongSerializer;
- typedef std::shared_ptr<LongSerializer> LongSerializerPtr;
-
- class LongSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::LongNavigator, LongSerializer>
- {
- public:
- /* constructors */
- LongSerializer(const typenavigator::LongNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.h
deleted file mode 100644
index 59bf310ccdac6edc8a14fe2fd4e07d9fa610f371..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/String.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class StringSerializer;
- typedef std::shared_ptr<StringSerializer> StringSerializerPtr;
-
- class StringSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::StringNavigator, StringSerializer>
- {
- public:
- /* constructors */
- StringSerializer(const typenavigator::StringNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.cpp
deleted file mode 100644
index a44838e4a29a2705cf4ddf16da1b479827f5ad46..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include "Time.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- /* constructors */
- TimeSerializer::TimeSerializer(const typenavigator::TimeNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::TimeNavigator, TimeSerializer>(
- "IceUtil::Time",
- simox::meta::get_type_name<data::AronLong>(),
- simox::meta::get_type_name<type::AronTime>(),
- e)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- }
-
- /* virtual implementations */
- CppBlockPtr TimeSerializer::getWriteTypeBlock(const std::string& accessor) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeTime({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
- return b;
- }
-
- CppBlockPtr TimeSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string resolved_accessor = this->ResolveMaybeAccessor(accessor, this->typenavigator);
- block_if_data->addLine("w.writePrimitive(" + resolved_accessor + nextEl() + "toMicroSeconds()); // of " + accessor);
-
- return this->ResolveMaybeWriteBlock(accessor, block_if_data, this->typenavigator);
- }
-
- CppBlockPtr TimeSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- std::string escaped_accessor = EscapeAccessor(accessor);
- std::string resolved_accessor = ResolveMaybeAccessor(accessor, typenavigator);
- block_if_data->addLine("long " + escaped_accessor + TIME_SETTER_ACCESSOR_SUFFIX + ";");
- block_if_data->addLine("r.readEndPrimitive(" + escaped_accessor + TIME_SETTER_ACCESSOR_SUFFIX + "); // of " + accessor);
- block_if_data->addLine(resolved_accessor + " = IceUtil::Time::microSeconds(" + escaped_accessor + TIME_SETTER_ACCESSOR_SUFFIX + ");");
- return this->ResolveMaybeReadBlock(accessor, "r.readStartPrimitive()", block_if_data, typenavigator);
- }
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.h
deleted file mode 100644
index 96b0322c0ab8a1b45d74a1560ec08ba5d3c9db14..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Time.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Time.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- class TimeSerializer;
- typedef std::shared_ptr<TimeSerializer> TimeSerializerPtr;
-
- class TimeSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::TimeNavigator, TimeSerializer>
- {
- public:
- /* constructors */
- TimeSerializer(const typenavigator::TimeNavigatorPtr& e);
-
- /* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getWriteBlock(const std::string& accessor) const override;
- virtual CppBlockPtr getReadBlock(const std::string& accessor) const override;
-
- private:
- static const constexpr char* TIME_SETTER_ACCESSOR_SUFFIX = "__time_setter";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.cpp
deleted file mode 100644
index f5f62b9215ebd3904405184605d6d5df9fc1298e..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "ObjectClass.h"
-
-#include <SimoxUtility/meta/type_name.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
- // constructors
- ObjectClassSerializer::ObjectClassSerializer(const typenavigator::ObjectNavigatorPtr& e) :
- detail::SerializerBase<typenavigator::ObjectNavigator, ObjectClassSerializer>(
- e->getObjectName(),
- simox::meta::get_type_name<data::AronDict>(),
- simox::meta::get_type_name<type::AronObject>(),
- e)
- {
- ARMARX_CHECK_NOT_NULL(typenavigator);
- if (typenavigator->getMaybe() != type::Maybe::eNone)
- {
- throw error::MaybeNotValidException("ObjectClassSerializer", "ObjectClassSerializer", "Somehow the maybe flag of a top level object declaration is set. This is not valid!", typenavigator->getMaybe(), typenavigator->getPath());
- }
- }
-
- std::vector<CppFieldPtr> ObjectClassSerializer::getPublicVariableDeclarations(const std::string&) const
- {
- std::vector<CppFieldPtr> fields;
- for (const auto& [key, member] : typenavigator->getMemberTypes())
- {
- auto member_s = FromAronTypeNaviagtorPtr(member);
- std::vector<CppFieldPtr> member_fields = member_s->getPublicVariableDeclarations(key);
- fields.insert(fields.end(), member_fields.begin(), member_fields.end());
- }
- return fields;
- }
-
- std::vector<std::pair<std::string, std::string>> ObjectClassSerializer::getCtorInitializers(const std::string&) const
- {
- return {};
- }
-
- CppBlockPtr ObjectClassSerializer::getCtorBlock(const std::string&) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- return b;
- }
-
- CppBlockPtr ObjectClassSerializer::getResetSoftBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- block_if_data->addLine(extends_s->getFullCppTypename() + "::resetSoft();");
- }
-
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- auto child_s = FromAronTypeNaviagtorPtr(child);
- CppBlockPtr b2 = child_s->getResetSoftBlock(key);
- block_if_data->appendBlock(b2);
- }
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectClassSerializer::getResetHardBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- block_if_data->addLine(extends_s->getFullCppTypename() + "::resetHard();");
- }
-
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- const auto child_s = FromAronTypeNaviagtorPtr(child);
- CppBlockPtr b2 = child_s->getResetHardBlock(key);
- block_if_data->appendBlock(b2);
- }
- return ResolveMaybeResetHardBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectClassSerializer::getWriteTypeBlock(const std::string&) const
- {
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeStartObject({\"" + typenavigator->getObjectName() + "\", __aronMaybeType}); // of top level object " + getCoreCppTypename());
-
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- b->addLine(extends_s->getFullCppTypename() + "::writeType(w, armarx::aron::type::Maybe::eNone, true);");
- b->addLine("w.writeExtends();");
- }
-
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- const auto child_s = FromAronTypeNaviagtorPtr(child);
- b->addLine("w.writeKey(\"" + key + "\");");
- CppBlockPtr b2 = child_s->getWriteTypeBlock(child_s->getCoreCppTypename());
- b->appendBlock(b2);
- }
-
- b->addLine("if (!__aronExtends)");
- b->addLineAsBlock("w.writeEndObject(); // of top level object " + getCoreCppTypename());
-
- return b;
- }
-
- CppBlockPtr ObjectClassSerializer::getWriteBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
-
- block_if_data->addLine("if (!__aronExtends)");
- block_if_data->addLineAsBlock("w.writeStartDict(); // of top level object " + getCoreCppTypename());
-
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- block_if_data->addLine(extends_s->getFullCppTypename() + "::write(w, true);");
- }
-
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- const auto child_s = FromAronTypeNaviagtorPtr(child);
- CppBlockPtr child_b = CppBlockPtr(new CppBlock());
-
- child_b->addLine("w.writeKey(\"" + key + "\");");
- child_b->appendBlock(child_s->getWriteBlock(key));
- block_if_data->addBlock(child_b);
- block_if_data->addLine("");
- }
-
- block_if_data->addLine("if (!__aronExtends)");
- block_if_data->addLineAsBlock("w.writeEndDict(); // of top level object " + getCoreCppTypename());
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectClassSerializer::getReadBlock(const std::string& accessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- block_if_data->addLine(extends_s->getFullCppTypename() + "::read(r);");
- }
-
- block_if_data->addLine("if(!__aronIsMember)");
- block_if_data->addLineAsBlock("r.readStartDict(); // of top level object " + getCoreCppTypename());
-
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- const auto child_s = FromAronTypeNaviagtorPtr(child);
- block_if_data->addLine("r.loadMember(\"" + key + "\");");
- block_if_data->addBlock(child_s->getReadBlock(key));
- }
- block_if_data->addLine("r.readEndDict(); // of top level object " + getCoreCppTypename());
- return ResolveMaybeReadBlock(accessor, "", block_if_data, typenavigator);
- }
-
- CppBlockPtr ObjectClassSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
- {
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- if (typenavigator->getExtends() != nullptr)
- {
- const auto extends_s = FromAronTypeNaviagtorPtr(typenavigator->getExtends());
- block_if_data->addLine("if (not (" + extends_s->getFullCppTypename() + "::operator== (" + otherInstanceAccessor + ")))");
- block_if_data->addLineAsBlock("return false;");
- }
- for (const auto& [key, child] : typenavigator->getMemberTypes())
- {
- auto child_s = FromAronTypeNaviagtorPtr(child);
- CppBlockPtr b2 = child_s->getEqualsBlock(key, otherInstanceAccessor + "." + key);
- block_if_data->appendBlock(b2);
- }
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.h
deleted file mode 100644
index 3a7a314aa14113990d9d4aad5303b21f153c674c..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-
-
-namespace armarx::aron::cppserializer::serializer
-{
-
- class ObjectClassSerializer;
- typedef std::shared_ptr<ObjectClassSerializer> ObjectClassSerializerPtr;
-
- class ObjectClassSerializer :
- virtual public detail::SerializerBase<typenavigator::ObjectNavigator, ObjectClassSerializer>
- {
- public:
- // constructors
- ObjectClassSerializer(const typenavigator::ObjectNavigatorPtr&);
-
- // virtual implementations
- std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const;
- virtual std::vector<std::pair<std::string, std::string>> getCtorInitializers(const std::string&) const override;
- virtual CppBlockPtr getCtorBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
-
- private:
- // members
- static constexpr const char* EXTENDS_ITERATOR_ACCESSOR = "_extends";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/CodeWriter.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/CodeWriter.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/CodeWriter.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/CodeWriter.h
index d879b7178132274b2c1c9d50e55529b5d4beb7bb..0bbf6ca52012f1183d157d92b090a3fbd7b9a38e 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/CodeWriter.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/CodeWriter.h
@@ -33,11 +33,12 @@
// ArmarX
#include <ArmarXCore/libraries/cppgen/MetaClass.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h>
namespace armarx::aron::codegenerator
{
@@ -50,8 +51,10 @@ namespace armarx::aron::codegenerator
additionalIncludes(additionalIncludesFromXMLFile)
{}
- virtual void generateTypeObjects(const std::vector<codegeneratorhelper::GenerateObjectInfoPtr>&) = 0;
- virtual void generateTypeIntEnums(const std::vector<codegeneratorhelper::GenerateIntEnumInfoPtr>&) = 0;
+ virtual ~CodeWriter() = default;
+
+ virtual void generateTypeObjects(const std::vector<typereader::GenerateObjectInfo>&) = 0;
+ virtual void generateTypeIntEnums(const std::vector<typereader::GenerateIntEnumInfo>&) = 0;
std::vector<MetaClassPtr> getTypeClasses() const
{
@@ -66,9 +69,10 @@ namespace armarx::aron::codegenerator
std::vector<MetaClassPtr> typeClasses;
std::string producerName;
- std::vector<codegeneratorhelper::WriterInfoPtr> dataWriters;
- std::vector<codegeneratorhelper::ReaderInfoPtr> dataReaders;
- std::vector<codegeneratorhelper::WriterInfoPtr> initialTypeWriters;
+ std::vector<codegenerator::WriterInfo> dataWriters;
+ std::vector<codegenerator::ReaderInfo> dataReaders;
+ std::vector<codegenerator::StaticReaderInfo> staticDataReaders;
+ std::vector<codegenerator::WriterInfo> initialTypeWriters;
std::vector<std::string> additionalIncludes;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/SerializerFactory.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/Factory.h
similarity index 89%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/SerializerFactory.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/Factory.h
index 09656fc3861e0f92e95f87d3f19e825de45631a7..21c70af3a6b8f246a1c6692e43422ae2d91e9423 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/SerializerFactory.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/Factory.h
@@ -22,7 +22,9 @@
*/
#pragma once
-
+/*
+ *TODO Maybe it makes sense to have a unified factory interface for code generation for different languages
+ *
// STD/STL
#include <memory>
#include <string>
@@ -39,13 +41,11 @@
namespace armarx::aron::codegenerator
{
template <typename Input, typename Output>
- class SerializerFactory :
- virtual public aron::Factory<Input, Output>
+ class SerializerFactory
{
public:
SerializerFactory() = default;
virtual Output create(const Input&, const Path&) const = 0;
- virtual Output createSpecific(const Input&, const Path&) const = 0;
};
-}
+}*/
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h
similarity index 65%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h
index 30f5e54450020945bf1caec30e8be1c153fb17d9..2e2ad3d9950082d395a5b26d3d95331cd641b483 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/AronCppClass.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h
@@ -30,21 +30,18 @@
// ArmarX
#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/Reader.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/Writer.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/Writer.h>
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/data/rw/Reader.h>
+#include <RobotAPI/libraries/aron/core/data/rw/Writer.h>
+#include <RobotAPI/libraries/aron/core/type/rw/Writer.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
-namespace armarx::aron::cppserializer
-{
- class AronCppClass;
- typedef std::shared_ptr<AronCppClass> AronCppClassPtr;
+namespace armarx::aron::codegenerator::cpp
+{
class AronCppClass
{
- public:
- using PointerType = AronCppClassPtr;
-
public:
AronCppClass() = default;
virtual ~AronCppClass() = default;
@@ -54,11 +51,5 @@ namespace armarx::aron::cppserializer
/// Reset all member values of this class softly, meaning if a maybe type has a value, we reset only the value (not the full maybe type) and if an image has data (width, height) we keep the data and width and height and only reset teh pixel values
virtual void resetSoft() = 0;
-
- /// Set members according to loaded data in ReaderInterface. If skip_first_readStartDict is true, we skip the first call of r.readStartDict() (It was already called outside. This is important for nested classes)
- virtual void read(armarx::aron::dataIO::ReaderInterface& r, bool __aronIsMember) = 0;
-
- /// Set the data in WriterInterface to the values of this class. If a maybe type is null or false, this method calls w.writeNull().
- virtual void write(armarx::aron::dataIO::WriterInterface& w, bool __aronExtends) const = 0;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4524241501e40896ee26150bde92ae85713fadb7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.cpp
@@ -0,0 +1,338 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+
+// Simox
+#include <SimoxUtility/algorithm/string.h>
+
+// Header
+#include "Writer.h"
+
+// ArmarX
+
+namespace armarx::aron::codegenerator::cpp
+{
+ Writer::Writer(const std::string& producerName, const std::vector<std::string>& additionalIncludesFromXMLFile) :
+ CodeWriter(producerName, additionalIncludesFromXMLFile)
+ {
+ addSpecificWriterMethods();
+ addSpecificReaderMethods();
+ }
+
+ void Writer::addSpecificWriterMethods()
+ {
+ // The toAron Serializer is visible by default
+ {
+ codegenerator::WriterInfo toAron;
+ toAron.methodName = "toAron";
+ toAron.returnType = "armarx::aron::data::DictPtr";
+ toAron.writerClassType = "armarx::aron::data::writer::VariantWriter";
+ toAron.include = "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
+ toAron.enforceConversion = "armarx::aron::data::Dict::DynamicCastAndCheck";
+ dataWriters.push_back(toAron);
+ }
+
+ {
+ // The toAron Serializer is visible by default
+ codegenerator::WriterInfo toAronType;
+ toAronType.methodName = "toAronType";
+ toAronType.returnType = "armarx::aron::type::ObjectPtr";
+ toAronType.writerClassType = "armarx::aron::type::writer::VariantWriter";
+ toAronType.include = "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
+ toAronType.enforceConversion = "armarx::aron::type::Object::DynamicCastAndCheck";
+ initialTypeWriters.push_back(toAronType);
+ }
+
+ // toJSON Method
+ /*
+ {
+ codegenerator::WriterInfo toJSON;
+ toJSON.methodName = "toJSON";
+ toJSON.returnType = "nlohmann::json";
+ toJSON.writerClassType = "armarx::aron::data::writer::NlohmannJSONWriter";
+ toJSON.include = "<RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h>";
+ dataWriters.push_back(toJSON);
+ }
+ */
+ }
+
+ void Writer::addSpecificReaderMethods()
+ {
+ // The static FromAron Deserializer
+ {
+ codegenerator::StaticReaderInfo fromAron;
+ fromAron.methodName = "FromAron";
+ fromAron.argumentType = "armarx::aron::data::DictPtr";
+ fromAron.returnType = OWN_TYPE_NAME;
+ staticDataReaders.push_back(fromAron);
+ }
+
+ // The fromAron Deserializer is visible by default
+ {
+ codegenerator::ReaderInfo fromAron;
+ fromAron.methodName = "fromAron";
+ fromAron.argumentType = "armarx::aron::data::DictPtr";
+ fromAron.readerClassType = "armarx::aron::data::reader::VariantReader";
+ fromAron.include = "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
+ dataReaders.push_back(fromAron);
+ }
+
+ // fromJSON Method
+ /*
+ {
+ codegenerator::ReaderInfo fromJSON;
+ fromJSON.methodName = "fromJSON";
+ fromJSON.argumentType = "nlohmann::json";
+ fromJSON.readerClassType = "armarx::aron::data::reader::NlohmannJSONReader";
+ fromJSON.include = "<RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h>";
+ dataReaders.push_back(fromJSON);
+ }
+ */
+ }
+
+
+ void Writer::generateTypeObjects(const std::vector<typereader::GenerateObjectInfo>& generateObjects)
+ {
+ for (const auto& publicGenerateObjectType : generateObjects)
+ {
+ const auto type = publicGenerateObjectType.correspondingType;
+
+ //std::cout << "Generating: " << nav->getName() << std::endl;
+
+ // Convert to Object type and create class object
+ if (type == nullptr)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "An received public type is null. Abort due to error!");
+ }
+
+ generator::ObjectClass generator(*type);
+
+ CppClassPtr c = setupBasicCppClass(publicGenerateObjectType, generator);
+ setupMemberFields(c, publicGenerateObjectType.doc_members, generator);
+
+ if (type->getExtends() != nullptr)
+ {
+ generator::ObjectClass extendsSerializer(*type->getExtends());
+ c->addInherit("public " + extendsSerializer.getFullCppTypename());
+ }
+ else
+ {
+ c->addInherit("public armarx::aron::codegenerator::cpp::AronCppClass");
+ c->addInclude("<RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h>");
+ }
+
+ for (const std::string& s : additionalIncludes)
+ {
+ if (!s.empty())
+ {
+ c->addInclude(s);
+ }
+ }
+
+ // Writermethods
+ for (const codegenerator::WriterInfo& info : dataWriters)
+ {
+ if (!info.include.empty())
+ {
+ c->addInclude(info.include);
+ }
+ CppMethodPtr convert = generator.toSpecializedDataWriterMethod(info);
+ c->addMethod(convert);
+ }
+
+ // Add methods to set the member variables
+ for (const codegenerator::StaticReaderInfo& info : staticDataReaders)
+ {
+ CppMethodPtr convert = generator.toSpecializedStaticDataReaderMethod(info);
+ c->addMethod(convert);
+ }
+
+ // Add methods to set the member variables
+ for (const codegenerator::ReaderInfo& info : dataReaders)
+ {
+ if (!info.include.empty())
+ {
+ c->addInclude(info.include);
+ }
+ CppMethodPtr convert = generator.toSpecializedDataReaderMethod(info);
+ c->addMethod(convert);
+ }
+
+ // Typewritermethods
+ for (const codegenerator::WriterInfo& info : initialTypeWriters)
+ {
+ if (!info.include.empty())
+ {
+ c->addInclude(info.include);
+ }
+ CppMethodPtr convert = generator.toSpecializedTypeWriterMethod(info);
+ c->addMethod(convert);
+ }
+
+ typeClasses.push_back(c);
+ }
+ }
+
+ void Writer::generateTypeIntEnums(const std::vector<typereader::GenerateIntEnumInfo>& generateIntEnums)
+ {
+ for (const auto& publicGenerateIntEnumType : generateIntEnums)
+ {
+ const auto& nav = publicGenerateIntEnumType.correspondingType;
+ if (nav == nullptr)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "An received public type is null. Abort due to error!");
+ }
+
+ generator::IntEnumClass generator(*nav);
+
+ CppClassPtr c = setupBasicCppClass(publicGenerateIntEnumType, generator);
+ setupMemberFields(c, publicGenerateIntEnumType.doc_values, generator);
+
+ c->addInherit("public armarx::aron::codegenerator::cpp::AronCppClass");
+ c->addInclude("<RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/AronCppClass.h>");
+
+ // ctor
+ c->addCtor(generator.toCopyCtor(c->getName()));
+ c->addCtor(generator.toInnerEnumCtor(c->getName()));
+
+ // Specific methods
+ CppEnumPtr enumrepresentation = generator.toInnerEnumDefinition();
+ c->addInnerEnum(enumrepresentation);
+
+ CppMethodPtr toString = generator.toToStringMethod();
+ c->addMethod(toString);
+
+ CppMethodPtr fromString = generator.toFromStringMethod();
+ c->addMethod(fromString);
+
+ CppMethodPtr intConversion = generator.toIntMethod();
+ c->addMethod(intConversion);
+
+ CppMethodPtr enumAssignment = generator.toEnumAssignmentMethod();
+ c->addMethod(enumAssignment);
+
+ CppMethodPtr enumAssignment2 = generator.toCopyAssignmentMethod();
+ c->addMethod(enumAssignment2);
+
+ CppMethodPtr enumAssignment3 = generator.toIntAssignmentMethod();
+ c->addMethod(enumAssignment3);
+
+ typeClasses.push_back(c);
+ }
+ }
+
+ CppClassPtr Writer::setupBasicCppClass(const typereader::GenerateInfo& info, const Generator& gen) const
+ {
+ const std::string cppTypename = gen.getFullCppTypename();
+ std::vector<std::string> split = simox::alg::split(cppTypename, "::");
+ if (split.size() < 1)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The cpp name of an inner type was empty. Please check the type definition file if all object names are set correctly.");
+ }
+
+ std::vector<std::string> namespaces(split);
+ namespaces.pop_back();
+
+ CppClassPtr c = std::make_shared<CppClass>(namespaces, split[split.size() - 1]);
+
+ // Add includes and guard
+ std::string classDoc = "******************************************\n"
+ "* AUTOGENERATED CLASS. Please do NOT edit.\n"
+ "******************************************\n";
+
+ if (!info.doc_author.empty() or !info.doc_brief.empty())
+ {
+ classDoc += (info.doc_brief.empty() ? "" : " * @brief " + info.doc_brief + "\n");
+ classDoc += (info.doc_author.empty() ? "" : " * @author " + info.doc_author + "\n");
+ }
+ c->addClassDoc(classDoc);
+ c->setPragmaOnceIncludeGuard(true);
+ c->addInclude("<memory>");
+ c->addInclude("<string>");
+ c->addInclude("<vector>");
+ c->addInclude("<map>");
+ c->addInclude("<RobotAPI/interface/aron.h>");
+
+ c->addPublicField(std::string("using ") + OWN_TYPE_NAME + " = " + cppTypename + ";");
+
+ // ctor
+ c->addCtor(gen.toCtor(c->getName()));
+
+ // Generic methods
+ //std::cout << "Generate equals method" << std::endl;
+ CppMethodPtr equals = gen.toEqualsMethod();
+ c->addMethod(equals);
+
+ //std::cout << "Generate reset method" << std::endl;
+ CppMethodPtr resetHard = gen.toResetHardMethod();
+ c->addMethod(resetHard);
+
+ //std::cout << "Generate init method" << std::endl;
+ CppMethodPtr resetSoft = gen.toResetSoftMethod();
+ c->addMethod(resetSoft);
+
+ //std::cout << "Generate writeInit method" << std::endl;
+ CppMethodPtr writeType = gen.toWriteTypeMethod();
+ c->addMethod(writeType);
+
+ //std::cout << "Generate write method" << std::endl;
+ CppMethodPtr write = gen.toWriteMethod();
+ c->addMethod(write);
+
+ //std::cout << "Generate read method" << std::endl;
+ CppMethodPtr read = gen.toReadMethod();
+ c->addMethod(read);
+ return c;
+ }
+
+ void Writer::setupMemberFields(CppClassPtr& c, const std::map<std::string, std::string>& doc_members, const generator::ObjectClass& o) const
+ {
+ auto publicFields = o.getPublicVariableDeclarations("");
+ for (const auto& f : publicFields)
+ {
+ if (auto it = doc_members.find(f->getName()); it != doc_members.end())
+ {
+ f->setDoc("@brief " + it->second);
+ }
+ c->addPublicField(f);
+ }
+ }
+
+ void Writer::setupMemberFields(CppClassPtr& c, const std::map<std::string, std::string>& doc_members, const generator::IntEnumClass& o) const
+ {
+ auto publicFields = o.getPublicVariableDeclarations("");
+ for (const auto& f : publicFields)
+ {
+ if (auto it = doc_members.find(f->getName()); it != doc_members.end())
+ {
+ f->setDoc("@brief " + it->second);
+ }
+ c->addPublicField(f);
+ }
+ }
+}
+
+
+
+
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.h
similarity index 60%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.h
index 27812b01d4d8374ff108c294404dad4385f6b236..2e6cc994cb6e70042918567f40a38d5293bf94e6 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/Writer.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/Writer.h
@@ -30,21 +30,18 @@
#include <vector>
// Parent class
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/CodeWriter.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/CodeWriter.h>
// ArmarX
#include <ArmarXCore/libraries/cppgen/CppMethod.h>
#include <ArmarXCore/libraries/cppgen/CppClass.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/ObjectClass.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h>
-namespace armarx::aron::cppserializer
+namespace armarx::aron::codegenerator::cpp
{
- class Writer;
- typedef std::shared_ptr<Writer> WriterPtr;
-
class Writer :
virtual public codegenerator::CodeWriter
{
@@ -52,20 +49,21 @@ namespace armarx::aron::cppserializer
Writer() = delete;
Writer(const std::string&, const std::vector<std::string>&);
- virtual void generateTypeObjects(const std::vector<codegeneratorhelper::GenerateObjectInfoPtr>&) override;
- virtual void generateTypeIntEnums(const std::vector<codegeneratorhelper::GenerateIntEnumInfoPtr>&) override;
+ virtual ~Writer() = default;
+
+ virtual void generateTypeObjects(const std::vector<typereader::GenerateObjectInfo>&) override;
+ virtual void generateTypeIntEnums(const std::vector<typereader::GenerateIntEnumInfo>&) override;
protected:
virtual void addSpecificWriterMethods() override;
virtual void addSpecificReaderMethods() override;
- private:
- void generateInnerTypeObjects(CppClassPtr& classToAdd, const std::map<std::string, codegeneratorhelper::GenerateObjectInfoPtr>& localGenerateTypes);
-
- CppClassPtr setupBasicCppClass(const std::string&) const;
- void setupMemberFields(CppClassPtr&, const std::map<std::string, std::string>& doc_members, const serializer::ObjectClassSerializerPtr&) const;
- void setupMemberFields(CppClassPtr&, const std::map<std::string, std::string>& doc_members, const serializer::IntEnumClassSerializerPtr&) const;
+ CppClassPtr setupBasicCppClass(const typereader::GenerateInfo& info, const Generator& gen) const;
+ void setupMemberFields(CppClassPtr&, const std::map<std::string, std::string>& doc_members, const generator::ObjectClass&) const;
+ void setupMemberFields(CppClassPtr&, const std::map<std::string, std::string>& doc_members, const generator::IntEnumClass&) const;
private:
+ static const constexpr char* OWN_TYPE_NAME = "This";
+
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bf1afd6b3666ecf805351ee3ca8880f49cadf7c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/All.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "toplevel/All.h"
+#include "container/All.h"
+#include "ndarray/All.h"
+#include "enum/All.h"
+#include "primitive/All.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..073d285e1be96452454ec8d9aca837245d7a72f7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.cpp
@@ -0,0 +1,66 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// STD/STL
+
+// Header
+#include "Factory.h"
+
+// ArmarX
+#include "All.h"
+#include "enum/All.h"
+
+namespace armarx::aron::codegenerator::cpp
+{
+ // Access method
+ std::unique_ptr<Generator> GeneratorFactory::create(const type::Variant& n, const Path& path) const
+ {
+ auto desc = n.getDescriptor();
+ switch(desc)
+ {
+ case type::Descriptor::eList: return std::make_unique<generator::List>(dynamic_cast<const type::List&>(n));
+ case type::Descriptor::eDict: return std::make_unique<generator::Dict>(dynamic_cast<const type::Dict&>(n));
+ case type::Descriptor::eObject: return std::make_unique<generator::Object>(dynamic_cast<const type::Object&>(n));
+ case type::Descriptor::eTuple: return std::make_unique<generator::Tuple>(dynamic_cast<const type::Tuple&>(n));
+ case type::Descriptor::ePair: return std::make_unique<generator::Pair>(dynamic_cast<const type::Pair&>(n));
+ case type::Descriptor::eNDArray: return std::make_unique<generator::NDArray>(dynamic_cast<const type::NDArray&>(n));
+ case type::Descriptor::eMatrix: return std::make_unique<generator::Matrix>(dynamic_cast<const type::Matrix&>(n));
+ case type::Descriptor::eQuaternion: return std::make_unique<generator::Quaternion>(dynamic_cast<const type::Quaternion&>(n));
+ case type::Descriptor::eImage: return std::make_unique<generator::Image>(dynamic_cast<const type::Image&>(n));
+ case type::Descriptor::ePointCloud: return std::make_unique<generator::PointCloud>(dynamic_cast<const type::PointCloud&>(n));
+ case type::Descriptor::ePosition: return std::make_unique<generator::Position>(dynamic_cast<const type::Position&>(n));
+ case type::Descriptor::eOrientation: return std::make_unique<generator::Orientation>(dynamic_cast<const type::Orientation&>(n));
+ case type::Descriptor::ePose: return std::make_unique<generator::Pose>(dynamic_cast<const type::Pose&>(n));
+ case type::Descriptor::eIntEnum: return std::make_unique<generator::IntEnum>(dynamic_cast<const type::IntEnum&>(n));
+ case type::Descriptor::eInt: return std::make_unique<generator::Int>(dynamic_cast<const type::Int&>(n));
+ case type::Descriptor::eLong: return std::make_unique<generator::Long>(dynamic_cast<const type::Long&>(n));
+ case type::Descriptor::eFloat: return std::make_unique<generator::Float>(dynamic_cast<const type::Float&>(n));
+ case type::Descriptor::eDouble: return std::make_unique<generator::Double>(dynamic_cast<const type::Double&>(n));
+ case type::Descriptor::eString: return std::make_unique<generator::String>(dynamic_cast<const type::String&>(n));
+ case type::Descriptor::eBool: return std::make_unique<generator::Bool>(dynamic_cast<const type::Bool&>(n));
+ case type::Descriptor::eTime: return std::make_unique<generator::Time>(dynamic_cast<const type::Time&>(n));
+ default: throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Cannot create a generator", std::to_string((int) desc), path);;
+ }
+ }
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f30af2290817eba9bb510047c216fa4d0265746
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Factory.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <unordered_map>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/All.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+namespace armarx::aron::codegenerator::cpp
+{
+ class GeneratorFactory
+ {
+ public:
+ GeneratorFactory() = default;
+ std::unique_ptr<Generator> create(const type::Variant&, const Path&) const;
+
+ virtual ~GeneratorFactory() = default;
+
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..911555fea595a1c426b9e4c90c0c0c0c3b772e5e
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.cpp
@@ -0,0 +1,459 @@
+/*
+* This file is part of ArmarX.
+*
+* Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+* Karlsruhe Institute of Technology (KIT), all rights reserved.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+
+#include "Generator.h"
+#include "Factory.h"
+
+#include <SimoxUtility/meta/type_name.h>
+#include <SimoxUtility/algorithm/string.h>
+
+
+namespace armarx::aron::codegenerator::cpp
+{
+ // constantes
+ const std::string Generator::ARON_VARIABLE_PREFIX = "aron";
+
+ const std::string Generator::ARON_MAYBE_TYPE_ACCESSOR = Generator::ARON_VARIABLE_PREFIX + "_maybeType";
+ const std::string Generator::ARON_READER_ACCESSOR = Generator::ARON_VARIABLE_PREFIX + "_r";
+ const std::string Generator::ARON_WRITER_ACCESSOR = Generator::ARON_VARIABLE_PREFIX + "_w";
+ const std::string Generator::ARON_VARIANT_RETURN_ACCESSOR = Generator::ARON_VARIABLE_PREFIX + "_variant";
+
+ const SerializerFactoryPtr Generator::FACTORY = SerializerFactoryPtr(new GeneratorFactory());
+
+ // static methods
+ std::string Generator::EscapeAccessor(const std::string& accessor)
+ {
+ const static std::map<std::string, std::string> ESCAPE_ACCESSORS =
+ {
+ {"->", "_ptr_"},
+ {".", "_dot_"},
+ {"[", "_lbrC_"},
+ {"]", "_rbrC_"},
+ {"(", "_lbrR_"},
+ {")", "_rbrR_"},
+ {"*", "_ast_"}
+ };
+
+ std::string escaped_accessor = accessor;
+ for (const auto& [key, value] : ESCAPE_ACCESSORS)
+ {
+ escaped_accessor = simox::alg::replace_all(escaped_accessor, key, value);
+ }
+ return escaped_accessor;
+ }
+
+ std::string Generator::ExtractCppTypename(const type::Variant& n)
+ {
+ auto cpp = Generator::FromAronType(n);
+ ARMARX_CHECK_NOT_NULL(cpp);
+ return cpp->getCoreCppTypename();
+ }
+ std::vector<std::string> Generator::ExtractCppTypenames(const std::vector<type::VariantPtr>& n)
+ {
+ std::vector<std::string> ret;
+ for (const auto& v : n)
+ {
+ ret.push_back(ExtractCppTypename(*v));
+ }
+ return ret;
+ }
+
+ std::unique_ptr<Generator> Generator::FromAronType(const type::Variant& n)
+ {
+ return FACTORY->create(n, n.getPath());
+ }
+
+
+ // constructors
+ Generator::Generator(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename) :
+ cppTypename(cppName),
+ aronDataTypename(aronDataTypename),
+ aronTypeTypename(aronTypeTypename)
+ {
+
+ }
+
+ // public methods
+ std::string Generator::getCoreCppTypename() const
+ {
+ return cppTypename;
+ }
+
+ std::string Generator::getFullCppTypename() const
+ {
+ switch (getType().getMaybe())
+ {
+ case type::Maybe::eNone:
+ return getCoreCppTypename();
+ case type::Maybe::eOptional:
+ return "std::optional<" + getCoreCppTypename() + ">";
+ case type::Maybe::eRawPointer:
+ return getCoreCppTypename() + "*";
+ case type::Maybe::eSharedPointer:
+ return "std::shared_ptr<" + getCoreCppTypename() + ">";
+ case type::Maybe::eUniquePointer:
+ return "std::unique_ptr<" + getCoreCppTypename() + ">";
+ default:
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Received unknown maybe enum", std::to_string((int) getType().getMaybe()), getType().getPath());
+ }
+ }
+
+ CppCtorPtr Generator::toCtor(const std::string& name) const
+ {
+ CppCtorPtr c = CppCtorPtr(new CppCtor(name + "()"));
+ std::vector<std::pair<std::string, std::string>> initList = this->getCtorInitializers("");
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("resetHard();");
+ b->appendBlock(this->getCtorBlock(""));
+ c->addInitListEntries(initList);
+ c->setBlock(b);
+
+ return c;
+ }
+
+ CppMethodPtr Generator::toResetSoftMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief resetSoft() - This method resets all member variables with respect to the current parameterization. \n";
+ doc << "@return - nothing";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void resetSoft() override", doc.str()));
+ CppBlockPtr b = this->getResetSoftBlock("");
+ m->setBlock(b);
+ return m;
+ }
+
+ CppMethodPtr Generator::toResetHardMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief resetHard() - This method resets member variables according to the XML type description. \n";
+ doc << "@return - nothing";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("virtual void resetHard() override", doc.str()));
+ CppBlockPtr b = this->getResetHardBlock("");
+ m->setBlock(b);
+ return m;
+ }
+
+ CppMethodPtr Generator::toWriteTypeMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief writeType() - This method returns a new type from the class structure using a type writer implementation. This function is static. \n";
+ doc << "@return - the result of the writer implementation";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("template<class T>\nstatic T writeType(armarx::aron::type::WriterInterface<T>& w, armarx::aron::type::Maybe "+ ARON_MAYBE_TYPE_ACCESSOR +" = armarx::aron::type::Maybe::eNone)", doc.str()));
+ std::string dummy;
+ CppBlockPtr b = this->getWriteTypeBlock("", "", dummy);
+ m->setBlock(b);
+ return m;
+ }
+
+ CppMethodPtr Generator::toWriteMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief write() - This method returns a new type from the member data types using a data writer implementation. \n";
+ doc << "@param w - The writer implementation\n";
+ doc << "@return - the result of the writer implementation";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("template<class T>\nT write(armarx::aron::data::WriterInterface<T>& w) const", doc.str()));
+ std::string dummy;
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->appendBlock(this->getWriteBlock("", dummy));
+ m->setBlock(b);
+ return m;
+ }
+
+ CppMethodPtr Generator::toReadMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief read() - This method sets the struct members to new values given in a data reader implementation. \n";
+ doc << "@param r - The reader implementation\n";
+ doc << "@return - nothing";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("template<class T>\nvoid read(armarx::aron::data::ReaderInterface<T>& r, T& input)", doc.str()));
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("using TNonConst = typename std::remove_const<T>::type;");
+ b->addLine("this->resetSoft();");
+ b->addLine("if (r.readNull(input))");
+ b->addLineAsBlock("throw armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"The input to the read method must not be null.\");");
+ b->appendBlock(this->getReadBlock("", "input"));
+ m->setBlock(b);
+ return m;
+ }
+
+ CppMethodPtr Generator::toSpecializedDataWriterMethod(const WriterInfo& info) const
+ {
+ std::stringstream doc;
+ doc << "@brief " << info.methodName << "() - This method returns a new data from the member data types using a writer implementation. \n";
+ doc << "@return - the result of the writer implementation";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod(info.returnType + " " + info.methodName + "() const", doc.str()));
+ m->addLine(info.writerClassType + " writer;");
+ m->addLine("return " + info.enforceConversion + "(this->write(writer));");
+ return m;
+ }
+
+ CppMethodPtr Generator::toSpecializedDataReaderMethod(const ReaderInfo& info) const
+ {
+ std::stringstream doc;
+ doc << "@brief " << info.methodName << " - This method sets the struct members to new values given in a reader implementation. \n";
+ doc << "@return - nothing";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("void " + info.methodName + "(const " + info.argumentType + "& input)", doc.str()));
+ m->addLine(info.readerClassType + " reader;");
+ m->addLine("this->read<" + info.readerClassType + "::InputType>(reader, " + info.enforceConversion + "(input));");
+ return m;
+ }
+
+ CppMethodPtr Generator::toSpecializedStaticDataReaderMethod(const StaticReaderInfo& info) const
+ {
+ std::stringstream doc;
+ doc << "@brief " << info.methodName << "() - This method sets the struct members to new values given in a reader implementation. \n";
+ doc << "@return - nothing";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("static " + info.returnType + " " + info.methodName + "(const " + info.argumentType + "& input)", doc.str()));
+ m->addLine("This t;");
+ m->addLine("t.fromAron(input);");
+ m->addLine("return t;");
+ return m;
+ }
+
+ CppMethodPtr Generator::toSpecializedTypeWriterMethod(const WriterInfo& info) const
+ {
+ std::stringstream doc;
+ doc << "@brief " << info.methodName << "() - This method returns a new type from the member data types using a writer implementation. \n";
+ doc << "@return - the result of the writer implementation";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("static " + info.returnType + " " + info.methodName + "()", doc.str()));
+ m->addLine(info.writerClassType + " writer;");
+ m->addLine("return " + info.enforceConversion + "(writeType(writer));");
+ return m;
+ }
+
+ CppMethodPtr Generator::toEqualsMethod() const
+ {
+ std::stringstream doc;
+ doc << "@brief operator==() - This method checks whether all values equal another instance. \n";
+ doc << "@param i - The other instance\n";
+ doc << "@return - true, if all members are the same, false otherwise";
+
+ CppMethodPtr m = CppMethodPtr(new CppMethod("bool operator==(const " + this->getFullCppTypename() + "& i) const", doc.str()));
+ CppBlockPtr b = this->getEqualsBlock("", "i");
+ b->addLine("return true;");
+ m->setBlock(b);
+ return m;
+ }
+
+ // defaulted implementations of the blocks
+ std::vector<CppFieldPtr> Generator::getPublicVariableDeclarations(const std::string& name) const
+ {
+ auto field = std::make_shared<CppField>(this->getFullCppTypename(), name);
+ return {field};
+ }
+
+ std::vector<std::pair<std::string, std::string>> Generator::getCtorInitializers(const std::string&) const
+ {
+ return {};
+ }
+
+ CppBlockPtr Generator::getCtorBlock(const std::string&) const
+ {
+ return std::make_shared<CppBlock>();
+ }
+
+ CppBlockPtr Generator::getResetHardBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + " = " + this->getFullCppTypename() + "();");
+ return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Generator::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ auto block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + " = " + this->getFullCppTypename() + "();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Generator::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = this->resolveMaybeAccessor(accessor);
+ std::string other_instance_resolved_accessor = this->resolveMaybeAccessor(otherInstanceAccessor);
+
+ block_if_data->addLine("if (not (" + resolved_accessor + " == " + other_instance_resolved_accessor + "))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+
+
+ // Helper methods
+ std::string Generator::resolveMaybeAccessor(const std::string& s) const
+ {
+ const auto& t = getType();
+ if (t.getMaybe() == type::Maybe::eOptional)
+ {
+ return s + ".value()";
+ }
+ if (t.getMaybe() == type::Maybe::eRawPointer || t.getMaybe() == type::Maybe::eSharedPointer || t.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ return "*" + s;
+ }
+ return s;
+ }
+
+ std::string Generator::resolveMaybeGenerator(const std::string& s) const
+ {
+ const auto& t = getType();
+ if (t.getMaybe() == type::Maybe::eOptional)
+ {
+ return s + " = std::make_optional<" + getCoreCppTypename() + ">();";
+ }
+ if (t.getMaybe() == type::Maybe::eRawPointer)
+ {
+ return s + " = new " + getCoreCppTypename() + "();";
+ }
+ if (t.getMaybe() == type::Maybe::eSharedPointer)
+ {
+ return s + " = std::make_shared<" + getCoreCppTypename() + ">();";
+ }
+ if (t.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ return s + " = std::make_unique<" + getCoreCppTypename() + ">();";
+ }
+ return "";
+ }
+
+ std::string Generator::nextEl() const
+ {
+ const auto& type = getType();
+ switch (type.getMaybe())
+ {
+ case type::Maybe::eNone:
+ return ".";
+ case type::Maybe::eOptional: //[[fallthrough]];
+ case type::Maybe::eRawPointer: //[[fallthrough]];
+ case type::Maybe::eSharedPointer: //[[fallthrough]];
+ case type::Maybe::eUniquePointer:
+ return "->";
+ default:
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Received unknown maybe enum", std::to_string((int) type.getMaybe()), type.getPath());
+ }
+ }
+
+ std::string Generator::toPointerAccessor(const std::string& cppAccessor) const
+ {
+ const auto& type = getType();
+ switch (type.getMaybe())
+ {
+ case type::Maybe::eRawPointer:
+ return cppAccessor;
+ case type::Maybe::eSharedPointer: //[[fallthrough]];
+ case type::Maybe::eUniquePointer:
+ return cppAccessor + ".get()";
+ default:
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Received invalid maybe enum (not a pointer?)", std::to_string((int) type.getMaybe()), type.getPath());
+ }
+ }
+
+ CppBlockPtr Generator::resolveMaybeResetHardBlock(const CppBlockPtr& block_if_data, const std::string& cppAccessor) const
+ {
+ const auto& type = getType();
+ if (type.getMaybe() == type::Maybe::eOptional)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine(cppAccessor + " = std::nullopt;");
+ return b;
+ }
+ else if (type.getMaybe() == type::Maybe::eRawPointer || type.getMaybe() == type::Maybe::eSharedPointer || type.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine(cppAccessor + " = nullptr;");
+ return b;
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr Generator::resolveMaybeResetSoftBlock(const CppBlockPtr& block_if_data, const std::string& cppAccessor) const
+ {
+ const auto& type = getType();
+ if (type.getMaybe() == type::Maybe::eOptional || type.getMaybe() == type::Maybe::eRawPointer || type.getMaybe() == type::Maybe::eSharedPointer || type.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("if (" + cppAccessor + ") // if " + cppAccessor + " contains data");
+ b->addBlock(block_if_data);
+ return b;
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr Generator::resolveMaybeWriteBlock(const CppBlockPtr& block_if_data, const std::string& cppAccessor) const
+ {
+ const auto& type = getType();
+ if (type.getMaybe() == type::Maybe::eOptional || type.getMaybe() == type::Maybe::eRawPointer || type.getMaybe() == type::Maybe::eSharedPointer || type.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("if (" + cppAccessor + ") // if " + cppAccessor + " contains data");
+ b->addBlock(block_if_data);
+ return b;
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr Generator::resolveMaybeReadBlock(const CppBlockPtr& block_if_data, const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ const auto& type = getType();
+ if (type.getMaybe() == type::Maybe::eOptional || type.getMaybe() == type::Maybe::eRawPointer || type.getMaybe() == type::Maybe::eSharedPointer || type.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("if (not (r.readNull(" + variantAccessor + "))) // if aron contains data");
+ {
+ CppBlockPtr ifb = std::make_shared<CppBlock>();
+ ifb->addLine(cppAccessor + " = " + getCoreCppTypename() + "();");
+ ifb->appendBlock(block_if_data);
+ b->addBlock(ifb);
+ }
+ return b;
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr Generator::resolveMaybeEqualsBlock(const CppBlockPtr& block_if_data, const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ const auto& type = getType();
+ if (type.getMaybe() == type::Maybe::eOptional || type.getMaybe() == type::Maybe::eRawPointer || type.getMaybe() == type::Maybe::eSharedPointer || type.getMaybe() == type::Maybe::eUniquePointer)
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("if (not ((bool) " + accessor + " == (bool) " + otherInstanceAccessor + ")) // check if both contain data");
+ b->addLineAsBlock("return false;");
+ b->addLine("if ((bool) " + accessor + " && (bool) " + otherInstanceAccessor + ")");
+ b->addBlock(block_if_data);
+ return b;
+ }
+ return block_if_data;
+ }
+}
+
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3978677fdc29f54fc1041d97b970780ecc37894a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.h
@@ -0,0 +1,181 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h>
+
+#include <ArmarXCore/libraries/cppgen/CppBlock.h>
+#include <ArmarXCore/libraries/cppgen/CppField.h>
+#include <ArmarXCore/libraries/cppgen/CppCtor.h>
+#include <ArmarXCore/libraries/cppgen/CppMethod.h>
+#include <ArmarXCore/libraries/cppgen/CppClass.h>
+
+#include <memory>
+#include <map>
+#include <string>
+#include <vector>
+
+
+namespace armarx::aron::codegenerator::cpp
+{
+
+ namespace conversion
+ {
+ const std::map<type::Maybe, std::string> Maybe2CppString =
+ {
+ {type::Maybe::eNone, "armarx::aron::type::Maybe::eNone"},
+ {type::Maybe::eOptional, "armarx::aron::type::Maybe::eOptional"},
+ {type::Maybe::eRawPointer, "armarx::aron::type::Maybe::eRawPointer"},
+ {type::Maybe::eSharedPointer, "armarx::aron::type::Maybe::eSharedPointer"},
+ {type::Maybe::eUniquePointer, "armarx::aron::type::Maybe::eUniquePointer"}
+ };
+
+ const std::map<type::matrix::ElementType, std::string> MatrixElementType2CppString =
+ {
+ {type::matrix::int16, "::armarx::aron::type::matrix::int16"},
+ {type::matrix::int32, "::armarx::aron::type::matrix::int32"},
+ {type::matrix::int64, "::armarx::aron::type::matrix::int64"},
+ {type::matrix::float32, "::armarx::aron::type::matrix::float32"},
+ {type::matrix::float64, "::armarx::aron::type::matrix::float64"}
+ };
+
+ const std::map<type::pointcloud::VoxelType, std::string> VoxelType2CppString =
+ {
+ {type::pointcloud::VoxelType::PointXYZ, "::armarx::aron::type::pointcloud::VoxelType::PointXYZ"},
+ {type::pointcloud::VoxelType::PointXYZI, "::armarx::aron::type::pointcloud::VoxelType::PointXYZI"},
+ {type::pointcloud::VoxelType::PointXYZL, "::armarx::aron::type::pointcloud::VoxelType::PointXYZL"},
+ {type::pointcloud::VoxelType::PointXYZRGB, "::armarx::aron::type::pointcloud::VoxelType::PointXYZRGB"},
+ {type::pointcloud::VoxelType::PointXYZRGBL, "::armarx::aron::type::pointcloud::VoxelType::PointXYZRGBL"},
+ {type::pointcloud::VoxelType::PointXYZRGBA, "::armarx::aron::type::pointcloud::VoxelType::PointXYZRGBA"},
+ {type::pointcloud::VoxelType::PointXYZHSV, "::armarx::aron::type::pointcloud::VoxelType::PointXYZHSV"}
+ };
+
+ const std::map<type::image::PixelType, std::string> PixelType2CppString =
+ {
+ {type::image::PixelType::rgb24, "::armarx::aron::type::image::PixelType::rgb24"},
+ {type::image::PixelType::depth32, "::armarx::aron::type::image::PixelType::depth32"}
+ };
+
+ const std::map<type::quaternion::ElementType, std::string> QuaternionElementType2Cpp =
+ {
+ {type::quaternion::ElementType::float32, "::armarx::aron::type::quaternion::ElementType::float32"},
+ {type::quaternion::ElementType::float64, "::armarx::aron::type::quaternion::ElementType::float64"}
+ };
+ }
+
+ class GeneratorFactory;
+ typedef std::shared_ptr<GeneratorFactory> SerializerFactoryPtr;
+
+ class Generator;
+ typedef std::shared_ptr<Generator> GeneratorPtr;
+
+ class Generator
+ {
+ public:
+ using PointerType = GeneratorPtr;
+
+ public:
+ // constructors
+ Generator() = delete;
+ Generator(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename);
+ virtual ~Generator() = default;
+
+ // public member methods
+ std::string getCoreCppTypename() const;
+ std::string getFullCppTypename() const;
+
+ CppMethodPtr toSpecializedDataWriterMethod(const WriterInfo& info) const;
+ CppMethodPtr toSpecializedDataReaderMethod(const ReaderInfo& info) const;
+ CppMethodPtr toSpecializedStaticDataReaderMethod(const StaticReaderInfo& info) const;
+ CppMethodPtr toSpecializedTypeWriterMethod(const WriterInfo& info) const;
+
+ // virtual override definitions
+ virtual std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const;
+
+ CppCtorPtr toCtor(const std::string&) const;
+ virtual std::vector<std::pair<std::string, std::string>> getCtorInitializers(const std::string&) const;
+ virtual CppBlockPtr getCtorBlock(const std::string&) const;
+
+ CppMethodPtr toResetSoftMethod() const;
+ virtual CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const;
+
+ CppMethodPtr toResetHardMethod() const;
+ virtual CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const;
+
+ CppMethodPtr toWriteTypeMethod() const;
+ virtual CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const = 0;
+
+ CppMethodPtr toWriteMethod() const;
+ virtual CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const = 0;
+
+ CppMethodPtr toReadMethod() const;
+ virtual CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const = 0;
+
+ CppMethodPtr toEqualsMethod() const;
+ virtual CppBlockPtr getEqualsBlock(const std::string& cppAccessorThis, const std::string& cppAccessorOther) const;
+
+ virtual const type::Variant& getType() const = 0;
+
+ // static methods
+ static std::string EscapeAccessor(const std::string&);
+ static std::string UnescapeAccessor(const std::string&);
+
+ static std::string ExtractCppTypename(const type::Variant&);
+ static std::vector<std::string> ExtractCppTypenames(const std::vector<type::VariantPtr>&);
+
+ static std::unique_ptr<Generator> FromAronType(const type::Variant&);
+
+ protected:
+ std::string nextEl() const;
+ std::string toPointerAccessor(const std::string&) const;
+
+ std::string resolveMaybeAccessor(const std::string&) const;
+ std::string resolveMaybeGenerator(const std::string&) const;
+
+ CppBlockPtr resolveMaybeResetHardBlock(const CppBlockPtr&, const std::string&) const;
+ CppBlockPtr resolveMaybeResetSoftBlock(const CppBlockPtr&, const std::string&) const;
+ CppBlockPtr resolveMaybeWriteBlock(const CppBlockPtr&, const std::string&) const;
+ CppBlockPtr resolveMaybeReadBlock(const CppBlockPtr&, const std::string&, const std::string&) const;
+ CppBlockPtr resolveMaybeEqualsBlock(const CppBlockPtr&, const std::string&, const std::string&) const;
+
+ protected:
+ static const std::string ARON_VARIABLE_PREFIX;
+
+ static const std::string ARON_MAYBE_TYPE_ACCESSOR;
+ static const std::string ARON_READER_ACCESSOR;
+ static const std::string ARON_WRITER_ACCESSOR;
+ static const std::string ARON_VARIANT_RETURN_ACCESSOR;
+
+ private:
+ static const SerializerFactoryPtr FACTORY;
+
+ std::string cppTypename;
+ std::string aronDataTypename;
+ std::string aronTypeTypename;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..444268f1da13d6701494a0e24b68419b64e47212
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/All.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Object.h"
+#include "List.h"
+#include "Dict.h"
+#include "Tuple.h"
+#include "Pair.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..38e18fc7050959c46a166c9e839c051674fa3aec
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.cpp
@@ -0,0 +1,114 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Dict.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ Dict::Dict(const type::Dict& e) :
+ detail::ContainerGenerator<type::Dict, Dict>("std::map<std::string, " + FromAronType(*e.getAcceptedType())->getFullCppTypename() + ">", simox::meta::get_type_name<data::dto::Dict>(), simox::meta::get_type_name<type::dto::Dict>(), e)
+ {
+ }
+
+ // virtual implementations
+ CppBlockPtr Dict::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "clear();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Dict::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ auto type_s = FromAronType(*type.getAcceptedType());
+ std::string nextVariantAccessor;
+ b->appendBlock(type_s->getWriteTypeBlock(type_s->getCoreCppTypename(), cppAccessor + nextEl() + "accepted_type", nextVariantAccessor));
+
+ //block_if_data->addLine("auto " + variantAccessor + )
+ b->addLine("auto " + variantAccessor + " = w.writeDict(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " + nextVariantAccessor + "); // of " + cppAccessor);
+
+ return b;
+ }
+
+ CppBlockPtr Dict::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ const std::string elementsAccessor = variantAccessor + "_dictElements";
+ block_if_data->addLine("std::map<std::string, T> " + elementsAccessor + ";");
+
+ std::string accessor_iterator_key = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_key";
+ std::string accessor_iterator_val = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_value";
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+
+ block_if_data->addLine("for (const auto& [" + accessor_iterator_key + ", " + accessor_iterator_val + "] : " + resolved_accessor + ") ");
+ {
+ auto type_s = FromAronType(*type.getAcceptedType());
+ CppBlockPtr for_loop = std::make_shared<CppBlock>();
+ std::string nextVariantAccessor;
+ auto child_b = type_s->getWriteBlock(accessor_iterator_val, nextVariantAccessor);
+ for_loop->addLine("auto " + nextVariantAccessor + " = w.writeNull();");
+ for_loop->appendBlock(child_b);
+ for_loop->addLine(elementsAccessor + ".emplace(" + accessor_iterator_key + ", " + nextVariantAccessor + ");");
+ block_if_data->addBlock(for_loop);
+ }
+ block_if_data->addLine(variantAccessor + " = w.writeDict(" + elementsAccessor + "); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Dict::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string elements_accessor = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_dictElements";
+ std::string accessor_iterator_value = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_dictValue";
+ std::string accessor_iterator_key = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_dictKey";
+
+ block_if_data->addLine("std::map<std::string, TNonConst> " + elements_accessor + ";");
+ block_if_data->addLine("r.readDict(" + variantAccessor + ", " + elements_accessor + ");");
+ block_if_data->addLine("for (const auto& [" + accessor_iterator_key + ", " + accessor_iterator_value + "] : " + elements_accessor + ")");
+ {
+ auto type_s = FromAronType(*type.getAcceptedType());
+ CppBlockPtr for_loop = std::make_shared<CppBlock>();
+ std::string accessor_iterator_tmp = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_dictTmp";
+ for_loop->addLine(type_s->getFullCppTypename() + " " + accessor_iterator_tmp +";");
+ for_loop->appendBlock(type_s->getReadBlock(accessor_iterator_tmp, accessor_iterator_value));
+ for_loop->addLine(cppAccessor + nextEl() + "insert({" + accessor_iterator_key + ", " + accessor_iterator_tmp + "});");
+ block_if_data->addBlock(for_loop);
+ }
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.h
new file mode 100644
index 0000000000000000000000000000000000000000..b20b13a3deca289890f1863925385d14c9802045
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Dict.h
@@ -0,0 +1,45 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/type/variant/container/Dict.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h>
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Dict :
+ public detail::ContainerGenerator<type::Dict, Dict>
+ {
+ public:
+ // constructors
+ Dict(const type::Dict&);
+ virtual ~Dict() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..991dc8d8ddfd263c256a4754a605964f7d2e47e7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.cpp
@@ -0,0 +1,109 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "List.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ List::List(const type::List& e) :
+ detail::ContainerGenerator<type::List, List>("std::vector<" + FromAronType(*e.getAcceptedType())->getFullCppTypename() + ">", simox::meta::get_type_name<data::dto::List>(), simox::meta::get_type_name<type::dto::List>(), e)
+ {
+ }
+
+ CppBlockPtr List::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "clear();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr List::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ auto type_s = FromAronType(*type.getAcceptedType());
+ std::string nextVariantAccessor;
+ CppBlockPtr b2 = type_s->getWriteTypeBlock(type_s->getCoreCppTypename(), cppAccessor + nextEl() + "accepted_type", nextVariantAccessor);
+ b->appendBlock(b2);
+
+ b->addLine("auto " + variantAccessor + " = w.writeList(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " + nextVariantAccessor + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr List::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ const std::string elementsAccessor = variantAccessor + "_listElements";
+ block_if_data->addLine("std::vector<T> " + elementsAccessor + ";");
+
+ std::string accessor_iterator = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_it";
+
+ auto type_s = FromAronType(*type.getAcceptedType());
+ block_if_data->addLine("for(unsigned int " + accessor_iterator + " = 0; " + accessor_iterator + " < " + cppAccessor + nextEl() + "size(); ++" + accessor_iterator + ")");
+ {
+ std::string nextVariantAccessor;
+ auto for_loop = std::make_shared<CppBlock>();
+ auto child_b = type_s->getWriteBlock(cppAccessor + nextEl() + "at(" + accessor_iterator + ")", nextVariantAccessor);
+ for_loop->addLine("auto " + nextVariantAccessor + " = w.writeNull();");
+ for_loop->appendBlock(child_b);
+ for_loop->addLine(elementsAccessor + ".push_back(" + nextVariantAccessor + ");");
+ block_if_data->addBlock(for_loop);
+ }
+ block_if_data->addLine(variantAccessor + " = w.writeList(" + elementsAccessor + "); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr List::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string elements_accessor = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_listElements";
+ std::string accessor_iterator_value = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_listValue";
+
+ block_if_data->addLine("std::vector<TNonConst> " + elements_accessor + ";");
+ block_if_data->addLine("r.readList(" + variantAccessor + ", " + elements_accessor + ");");
+ block_if_data->addLine("for (const auto& " + accessor_iterator_value + " : " + elements_accessor + ")");
+ {
+ CppBlockPtr for_loop = std::make_shared<CppBlock>();
+ auto type_s = FromAronType(*type.getAcceptedType());
+
+ std::string accessor_iterator_tmp = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_listTmp";
+ for_loop->addLine(type_s->getFullCppTypename() + " " + accessor_iterator_tmp + ";");
+ for_loop->appendBlock(type_s->getReadBlock(accessor_iterator_tmp, accessor_iterator_value));
+ for_loop->addLine(cppAccessor + nextEl() + "push_back(" + accessor_iterator_tmp + ");");
+ block_if_data->addBlock(for_loop);
+ }
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.h
new file mode 100644
index 0000000000000000000000000000000000000000..79867c9ff700fd3d08e47fdf8459257a830278d3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/List.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/type/variant/container/List.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class List :
+ public detail::ContainerGenerator<type::List, List>
+ {
+ public:
+ // constructors
+ List(const type::List&);
+ virtual ~List() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91620ba98abdb6920f2adf5a7aef1aa8e40475ab
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.cpp
@@ -0,0 +1,77 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Object.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ Object::Object(const type::Object& e) :
+ detail::ContainerGenerator<type::Object, Object>(e.getObjectName(), simox::meta::get_type_name<data::dto::Dict>(), simox::meta::get_type_name<type::dto::AronObject>(), e)
+ {
+ }
+
+
+ CppBlockPtr Object::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "resetSoft();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Object::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = " + getCoreCppTypename() + "::writeType(w, " + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Object::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = " + cppAccessor + nextEl() + "write(w); // of " + cppAccessor);
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Object::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ if (const auto reset = resolveMaybeGenerator(cppAccessor); !reset.empty())
+ {
+ block_if_data->addLine(reset);
+ }
+ block_if_data->addLine(cppAccessor + nextEl() + "read<T>(r, " + variantAccessor + "); // of " + cppAccessor);
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.h
new file mode 100644
index 0000000000000000000000000000000000000000..27410667647f3e793aede94677b54af60da1dc77
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Object.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Object :
+ public detail::ContainerGenerator<type::Object, Object>
+ {
+ public:
+ // constructors
+ Object(const type::Object&);
+ virtual ~Object() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cbcd26a0b0dd3b34e84bf53c5a87f19d0f0dc5ab
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.cpp
@@ -0,0 +1,118 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Pair.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ Pair::Pair(const type::Pair& e) :
+ detail::ContainerGenerator<type::Pair, Pair>("std::pair<" + ExtractCppTypename(*e.getFirstAcceptedType()) + ", " + ExtractCppTypename(*e.getSecondAcceptedType()) + ">", simox::meta::get_type_name<data::dto::List>(), simox::meta::get_type_name<type::dto::Pair>(), e)
+ {
+ }
+
+ CppBlockPtr Pair::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+
+ auto child_s1 = FromAronType(*type.getFirstAcceptedType());
+ CppBlockPtr b21 = child_s1->getResetSoftBlock(cppAccessor + nextEl() + "first");
+ block_if_data->appendBlock(b21);
+
+ auto child_s2 = FromAronType(*type.getSecondAcceptedType());
+ CppBlockPtr b22 = child_s2->getResetSoftBlock(cppAccessor + nextEl() + "second");
+ block_if_data->appendBlock(b22);
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Pair::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ auto child_s1 = FromAronType(*type.getFirstAcceptedType());
+ std::string accessor_iterator1 = cppAccessor + nextEl() + "first";
+ std::string firstVariantAccessor;
+ CppBlockPtr b21 = child_s1->getWriteTypeBlock(child_s1->getCoreCppTypename(), accessor_iterator1, firstVariantAccessor);
+ block_if_data->appendBlock(b21);
+
+ auto child_s2 = FromAronType(*type.getSecondAcceptedType());
+ std::string accessor_iterator2 = cppAccessor + nextEl() + "second";
+ std::string secondVariantAccessor;
+ CppBlockPtr b22 = child_s2->getWriteTypeBlock(child_s2->getCoreCppTypename(), accessor_iterator2, secondVariantAccessor);
+ block_if_data->appendBlock(b22);
+
+ block_if_data->addLine("auto " + variantAccessor + " = w.writePair("+conversion::Maybe2CppString.at(type.getMaybe())+", "+firstVariantAccessor+", "+secondVariantAccessor+"); // of " + cppAccessor);
+ return block_if_data;
+ }
+
+ CppBlockPtr Pair::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ auto child_s1 = FromAronType(*type.getFirstAcceptedType());
+ std::string accessor_iterator1 = cppAccessor + nextEl() + "first";
+ std::string firstVariantAccessor;
+ CppBlockPtr b21 = child_s1->getWriteBlock(accessor_iterator1, firstVariantAccessor);
+ block_if_data->addLine("auto " + firstVariantAccessor + " = w.writeNull();");
+ block_if_data->appendBlock(b21);
+
+ auto child_s2 = FromAronType(*type.getSecondAcceptedType());
+ std::string accessor_iterator2 = cppAccessor + nextEl() + "second";
+ std::string secondVariantAccessor;
+ CppBlockPtr b22 = child_s2->getWriteBlock(accessor_iterator2, secondVariantAccessor);
+ block_if_data->addLine("auto " + secondVariantAccessor + " = w.writeNull();");
+ block_if_data->appendBlock(b22);
+
+ block_if_data->addLine(variantAccessor + " = w.writePair("+firstVariantAccessor+", "+secondVariantAccessor+"); // of " + cppAccessor);
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Pair::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string elements_accessor = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_pairElements";
+
+ block_if_data->addLine("std::vector<TNonConst> " + elements_accessor + ";");
+ block_if_data->addLine("r.readList("+elements_accessor+"); // of " + cppAccessor);
+
+ auto child_s1 = FromAronType(*type.getFirstAcceptedType());
+ CppBlockPtr b21 = child_s1->getReadBlock(cppAccessor + nextEl() + "first", elements_accessor+"[0]");
+ block_if_data->appendBlock(b21);
+
+ auto child_s2 = FromAronType(*type.getSecondAcceptedType());
+ CppBlockPtr b22 = child_s2->getReadBlock(cppAccessor + nextEl() + "second", elements_accessor+"[1]");
+ block_if_data->appendBlock(b22);
+
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.h
new file mode 100644
index 0000000000000000000000000000000000000000..196ce6f51effa190191afee346f64842f5bd4f81
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Pair.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/type/variant/container/Pair.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Pair :
+ public detail::ContainerGenerator<type::Pair, Pair>
+ {
+ public:
+ // constructors
+ Pair(const type::Pair& e);
+ virtual ~Pair() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba08a5999390be0e423b19ddd6265322cbbdfd28
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.cpp
@@ -0,0 +1,121 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Tuple.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ Tuple::Tuple(const type::Tuple& e) :
+ detail::ContainerGenerator<type::Tuple, Tuple>("std::tuple<" + simox::alg::join(ExtractCppTypenames(e.getAcceptedTypes()), ", ") + ">", simox::meta::get_type_name<data::dto::List>(), simox::meta::get_type_name<type::dto::Tuple>(), e)
+ {
+ }
+
+ CppBlockPtr Tuple::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+
+ unsigned int i = 0;
+ for (const auto& child : type.getAcceptedTypes())
+ {
+ auto child_s = FromAronType(*child);
+ CppBlockPtr b2 = child_s->getResetSoftBlock("std::get<" + std::to_string(i++) + ">(" + resolved_accessor + ")");
+ block_if_data->appendBlock(b2);
+ }
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Tuple::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ const std::string acceptedTypesAccessor = variantAccessor + "_tupleAcceptedTypes";
+ block_if_data->addLine("std::vector<T> " + acceptedTypesAccessor + ";");
+
+ unsigned int i = 0;
+ for (const auto& type : type.getAcceptedTypes())
+ {
+ std::string accessor_iterator = "std::get<" + std::to_string(i) + ">("+resolved_accessor+");";
+ auto type_s = FromAronType(*type);
+ std::string nextVariantAccessor;
+ CppBlockPtr b2 = type_s->getWriteTypeBlock(type_s->getCoreCppTypename(), accessor_iterator, nextVariantAccessor);
+ block_if_data->appendBlock(b2);
+ block_if_data->addLine(acceptedTypesAccessor + ".push_back(" + nextVariantAccessor + ");");
+ }
+ block_if_data->addLine("auto " + variantAccessor + " = w.writeTuple("+conversion::Maybe2CppString.at(type.getMaybe())+", "+acceptedTypesAccessor+"); // of " + cppAccessor);
+ return block_if_data;
+ }
+
+ CppBlockPtr Tuple::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR+ "_" + escaped_accessor;
+
+ const std::string elementsAccessor = variantAccessor + "_tupleElements";
+ block_if_data->addLine("std::vector<T> " + elementsAccessor + ";");
+
+ unsigned int i = 0;
+ for (const auto& type : type.getAcceptedTypes())
+ {
+ std::string accessor_iterator = "std::get<" + std::to_string(i) + ">("+resolved_accessor+");";
+ auto type_s = FromAronType(*type);
+ std::string nextVariantAccessor;
+ CppBlockPtr b2 = type_s->getWriteBlock(accessor_iterator, nextVariantAccessor);
+ block_if_data->addLine("auto " + nextVariantAccessor + " = w.writeNull();");
+ block_if_data->appendBlock(b2);
+ block_if_data->addLine(elementsAccessor + ".push_back(" + nextVariantAccessor + ");");
+ }
+ block_if_data->addLine(variantAccessor+ " = w.writeTuple("+elementsAccessor+"); // of " + cppAccessor);
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Tuple::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+ std::string elements_accessor = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_tupleElements";
+
+ block_if_data->addLine("std::vector<TNonConst> " + elements_accessor + ";");
+ block_if_data->addLine("r.readList("+elements_accessor+"); // of " + cppAccessor);
+
+ unsigned int i = 0;
+ for (const auto& type : type.getAcceptedTypes())
+ {
+ auto type_s = FromAronType(*type);
+ CppBlockPtr b2 = type_s->getReadBlock("std::get<" + std::to_string(i) + ">(" + resolved_accessor + ")", elements_accessor+"[" + std::to_string(i) + "]");
+ block_if_data->appendBlock(b2);
+ i++;
+ }
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.h
new file mode 100644
index 0000000000000000000000000000000000000000..55d03d174f1c7b34fee371e7afce498fbedc4e23
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/container/Tuple.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/type/variant/container/Tuple.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Tuple :
+ public detail::ContainerGenerator<type::Tuple, Tuple>
+ {
+ public:
+ // constructors
+ Tuple(const type::Tuple& e);
+ virtual ~Tuple() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.cpp
index 98ecea508e8055664d1a300e29e3aac42cea1010..19cecad14565bb5033a5cf31c31e21a311d59995 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/NDArraySerializerBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.cpp
@@ -22,4 +22,4 @@
*/
// Header
-#include "NDArraySerializerBase.h"
+#include "ContainerGenerator.h"
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8a3da7bc6aabab454ca7c9bc065422bf74b4860
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/ContainerGenerator.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "SpecializedGenerator.h"
+
+
+namespace armarx::aron::codegenerator::cpp::generator::detail
+{
+ template<typename typeT, typename DerivedT>
+ class ContainerGenerator :
+ public SpecializedGeneratorBase<typeT, DerivedT>
+ {
+ public:
+ using SpecializedGeneratorBase<typeT, DerivedT>::SpecializedGeneratorBase;
+ virtual ~ContainerGenerator() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.cpp
index a5e8c5aa05314a73d33e01c14d01a38976ba88a3..12a326e0673af7a2d09dccface9d7a5a0a6e3a70 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.cpp
@@ -22,4 +22,4 @@
*/
// Header
-#include "NavigatorBase.h"
+#include "NDArrayGenerator.h"
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..834262520b99edede248c28b01fa39f9b3aa8153
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "SpecializedGenerator.h"
+
+
+namespace armarx::aron::codegenerator::cpp::generator::detail
+{
+ template<typename typeT, typename DerivedT>
+ class NDArrayGenerator :
+ public SpecializedGeneratorBase<typeT, DerivedT>
+ {
+ public:
+ using SpecializedGeneratorBase<typeT, DerivedT>::SpecializedGeneratorBase;
+ virtual ~NDArrayGenerator() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c3623a4d4dd89fb4ab56af34cdc3bf7a723ba26
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveGenerator.h"
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..43e304508a6985fc02ca9eae6571a5113b3640e3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h
@@ -0,0 +1,63 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "SpecializedGenerator.h"
+
+#include <string>
+
+
+namespace armarx::aron::codegenerator::cpp::generator::detail
+{
+ template<typename typeT, typename DerivedT>
+ class PrimitiveGenerator :
+ public SpecializedGeneratorBase<typeT, DerivedT>
+ {
+ public:
+ using SpecializedGeneratorBase<typeT, DerivedT>::SpecializedGeneratorBase;
+ virtual ~PrimitiveGenerator() = default;
+
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override
+ {
+ auto block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = this->resolveMaybeAccessor(cppAccessor);
+ std::string escaped_accessor = this->EscapeAccessor(cppAccessor);
+ variantAccessor = Generator::ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writePrimitive(" + resolved_accessor + "); // of " + cppAccessor);
+
+ return this->resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override
+ {
+ auto block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = this->resolveMaybeAccessor(cppAccessor);
+ std::string escaped_accessor = this->EscapeAccessor(cppAccessor);
+
+ block_if_data->addLine("r.readPrimitive("+variantAccessor+", " + resolved_accessor + "); // of " + cppAccessor);
+ return this->resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b216d6a2c6a4d1da7fc9d76eae2bd8b6931ca8d9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "SpecializedGenerator.h"
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..701ea582e42c8cbde959e184d82be46bd1897391
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h
@@ -0,0 +1,54 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/Generator.h>
+
+#include <memory>
+#include <string>
+
+
+namespace armarx::aron::codegenerator::cpp::generator::detail
+{
+ template<typename TypeT, typename DerivedT>
+ class SpecializedGeneratorBase :
+ public codegenerator::cpp::Generator
+ {
+ public:
+ SpecializedGeneratorBase(const std::string& cppName, const std::string& aronDataTypename, const std::string& aronTypeTypename, const TypeT& t) :
+ Generator(cppName, aronDataTypename, aronTypeTypename),
+ type(t)
+ {
+ }
+ virtual ~SpecializedGeneratorBase() = default;
+
+ virtual const type::Variant& getType() const override
+ {
+ return type;
+ }
+
+ protected:
+ TypeT type;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..c10804705a973fc89e66424d1f37b97a4503ac05
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/All.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "IntEnum.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8df7c65920d8b85444955251e974b2cd55c2f10
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.cpp
@@ -0,0 +1,90 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "IntEnum.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ IntEnum::IntEnum(const type::IntEnum& e) :
+ detail::SpecializedGeneratorBase<type::IntEnum, IntEnum>(e.getEnumName(), simox::meta::get_type_name<data::dto::NDArray>(), simox::meta::get_type_name<type::dto::IntEnum>(), e)
+ {
+ }
+
+ CppBlockPtr IntEnum::getResetSoftBlock(const std::string& accessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(accessor + nextEl() + "resetSoft();");
+ return block_if_data;
+ }
+
+ CppBlockPtr IntEnum::getResetHardBlock(const std::string& accessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ if (type.getMaybe() != type::Maybe::eNone)
+ {
+ b->addLine(accessor + " = {};");
+ }
+ else
+ {
+ b->addLine(accessor + nextEl() + "resetHard();");
+ }
+ return b;
+ }
+
+ CppBlockPtr IntEnum::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto "+variantAccessor+" = " +getCoreCppTypename() + "::writeType(w, " + conversion::Maybe2CppString.at(type.getMaybe()) + ");");
+ return b;
+ }
+
+ CppBlockPtr IntEnum::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor+" = " + cppAccessor + nextEl() + "write(w);");
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr IntEnum::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ if (const auto reset = resolveMaybeGenerator(cppAccessor); !reset.empty())
+ {
+ block_if_data->addLine(reset);
+ }
+ block_if_data->addLine(cppAccessor + nextEl() + "read<T>(r, " + variantAccessor + ");");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d0e35b09c6e6d2775648cb92ac67a6ccbc69e1a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/enum/IntEnum.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
+
+#include <map>
+#include <string>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class IntEnum;
+ typedef std::shared_ptr<IntEnum> IntEnumSerializerPtr;
+
+ class IntEnum :
+ public detail::SpecializedGeneratorBase<type::IntEnum, IntEnum>
+ {
+ public:
+ // constructors
+ IntEnum(const type::IntEnum&);
+ virtual ~IntEnum() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..04797adc4c1bc53fa0605eec7d764641b99871e3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/All.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "NDArray.h"
+#include "Matrix.h"
+#include "Quaternion.h"
+#include "Image.h"
+#include "PointCloud.h"
+#include "Position.h"
+#include "Orientation.h"
+#include "Pose.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d1226e52cea4a974c45f49e44ccaa9ed2e84a92
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.cpp
@@ -0,0 +1,115 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Image.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+
+ const std::map<type::image::PixelType, std::pair<std::string, int>> Image::PixelType2Cpp =
+ {
+ { type::image::PixelType::rgb24, {"CV_8UC3", 3}},
+ { type::image::PixelType::depth32, {"CV_32FC1", 4}},
+ };
+
+
+ // constructors
+ Image::Image(const type::Image& n) :
+ detail::NDArrayGenerator<type::Image, Image>("cv::Mat", simox::meta::get_type_name<data::dto::NDArray>(), simox::meta::get_type_name<type::dto::Image>(), n)
+ {
+ }
+
+ CppBlockPtr Image::getResetHardBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = detail::NDArrayGenerator<type::Image, Image>::getResetHardBlock(cppAccessor);
+ block_if_data->addLine(cppAccessor + ".create(0, 0, " + PixelType2Cpp.at(type.getPixelType()).first + ");");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Image::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + ".create(0, 0, " + PixelType2Cpp.at(type.getPixelType()).first + ");");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+
+ CppBlockPtr Image::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeImage(" + conversion::PixelType2CppString.at(type.getPixelType()) + ", " + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+
+ CppBlockPtr Image::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+ const std::string shape_vec = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_imageShape";
+ block_if_data->addLine("std::vector<int> " + shape_vec + "(" + cppAccessor + nextEl() + "size.p, " + cppAccessor + nextEl() + "size.p + " + cppAccessor + nextEl() + "dims);");
+ block_if_data->addLine(shape_vec+".push_back(" + cppAccessor + nextEl() + "elemSize());");
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray(" + shape_vec + ", std::to_string(" + cppAccessor + nextEl() + "type()), reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "data)); // of " + cppAccessor);
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+
+ CppBlockPtr Image::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine(cppAccessor + " = " + getCoreCppTypename() + "(std::vector<int>({" + dims + ".begin(), std::prev(" + dims + ".end())}), std::stoi(" + type + "));");
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "data), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+
+ CppBlockPtr Image::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string resolved_accessor = this->resolveMaybeAccessor(accessor);
+ std::string other_instance_resolved_accessor = this->resolveMaybeAccessor(otherInstanceAccessor);
+
+ block_if_data->addLine("if (cv::countNonZero(" + resolved_accessor + " != " + other_instance_resolved_accessor + ") != 0)");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
+
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c56ead469a3fba497d94b93154d06285d56b49f
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Image.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Image :
+ public detail::NDArrayGenerator<type::Image, Image>
+ {
+ public:
+
+ Image(const type::Image& n);
+ virtual ~Image() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
+
+ public:
+ /// Maps ARON pixel types to OpenCV image type constants.
+ static const std::map<type::image::PixelType, std::pair<std::string, int>> PixelType2Cpp;
+
+ };
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..825bf8dc779ac3cbfca696264f30890f9455248d
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.cpp
@@ -0,0 +1,103 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Matrix.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+
+ const std::map<type::matrix::ElementType, std::pair<std::string, int>> Matrix::ElementType2Cpp =
+ {
+ {type::matrix::int16, {"short", 2}},
+ {type::matrix::int32, {"int", 4}},
+ {type::matrix::int64, {"long", 8}},
+ {type::matrix::float32, {"float", 4}},
+ {type::matrix::float64, {"double", 8}}
+ };
+
+ // constructors
+ Matrix::Matrix(const type::Matrix& n) :
+ detail::NDArrayGenerator<type::Matrix, Matrix>("Eigen::Matrix<" + ElementType2Cpp.at(n.getElementType()).first + ", " + std::to_string(n.getRows()) + ", " + std::to_string(n.getCols()) + ">", simox::meta::get_type_name<data::dto::NDArray>(), simox::meta::get_type_name<type::dto::Matrix>(), n)
+ {
+ }
+
+ CppBlockPtr Matrix::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "setZero();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Matrix::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+ const std::string line_if_data = "auto " + variantAccessor + " = w.writeMatrix((int) " + std::to_string(type.getRows()) + ", (int) " + std::to_string(type.getCols()) + ", " + conversion::MatrixElementType2CppString.at(type.getElementType()) + ", " + conversion::Maybe2CppString.at(type.getMaybe()) + ")";
+
+ b->addLine(line_if_data + "; // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Matrix::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+ const std::string line_if_data = "w.writeNDArray({(int) " + cppAccessor + nextEl() + "rows(), (int) " + cppAccessor + nextEl() +
+ "cols(), " + std::to_string(ElementType2Cpp.at(type.getElementType()).second) + "}, \"" +
+ ElementType2Cpp.at(type.getElementType()).first + "\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() +
+ "data()));";
+
+ block_if_data->addLine(variantAccessor + " = " + line_if_data + " // of " + cppAccessor);
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Matrix::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr Matrix::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + resolveMaybeAccessor(otherInstanceAccessor) + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.h
new file mode 100644
index 0000000000000000000000000000000000000000..44a78d9ed546474d8cae36f73fa94e34d1e1cd29
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Matrix.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h>
+
+#include <map>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+
+ class Matrix :
+ public detail::NDArrayGenerator<type::Matrix, Matrix>
+ {
+ public:
+ // constructors
+ Matrix(const type::Matrix&);
+ virtual ~Matrix() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
+
+ public:
+ static const std::map<type::matrix::ElementType, std::pair<std::string, int>> ElementType2Cpp;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.cpp
index f9597ff4540e02bb7aba3e7ecf990467d88ae8be..ae7db10ce01bac5090f0486a4d6e8bd9710ad23c 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/ndarray/NDArray.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.cpp
@@ -27,41 +27,37 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
// constructors
- NDArraySerializer::NDArraySerializer(const typenavigator::NDArrayNavigatorPtr& n) :
- detail::NDArraySerializerBase<typenavigator::NDArrayNavigator, NDArraySerializer>(
- "NDArray",
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronNDArray>(),
- n)
+ NDArray::NDArray(const type::NDArray& n) :
+ detail::NDArrayGenerator<type::NDArray, NDArray>("NDArray", simox::meta::get_type_name<data::dto::NDArray>(), simox::meta::get_type_name<type::dto::NDArray>(), n)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
- CppBlockPtr NDArraySerializer::getWriteTypeBlock(const std::string&) const
+ CppBlockPtr NDArray::getResetSoftBlock(const std::string& cppAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- return b;
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + " = " + this->getFullCppTypename() + "();");
+ return resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
- CppBlockPtr NDArraySerializer::getWriteBlock(const std::string& accessor) const
+ CppBlockPtr NDArray::getWriteTypeBlock(const std::string&, const std::string&, std::string&) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
+ CppBlockPtr b = std::make_shared<CppBlock>();
return b;
}
- CppBlockPtr NDArraySerializer::getReadBlock(const std::string& accessor) const
+ CppBlockPtr NDArray::getWriteBlock(const std::string& cppAccessor, std::string&) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
+ CppBlockPtr b = std::make_shared<CppBlock>();
return b;
}
- CppBlockPtr NDArraySerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ CppBlockPtr NDArray::getReadBlock(const std::string& cppAccessor, const std::string&) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.h
new file mode 100644
index 0000000000000000000000000000000000000000..8127f2c6b8063aee2d272f044048bc4d2d072739
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/NDArray.h
@@ -0,0 +1,49 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h>
+
+#include <string>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class NDArray :
+ public detail::NDArrayGenerator<type::NDArray, NDArray>
+ {
+
+ public:
+ // constructors
+ NDArray(const type::NDArray&);
+ virtual ~NDArray() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5390f7830875677f0535e878cab17399aa15b58e
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.cpp
@@ -0,0 +1,90 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Orientation.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ Orientation::Orientation(const type::Orientation& n) :
+ detail::NDArrayGenerator<type::Orientation, Orientation>("Eigen::Quaternion<float>", simox::meta::get_type_name<data::dto::NDArray>(), simox::meta::get_type_name<type::dto::Orientation>(), n)
+ {
+ }
+
+ CppBlockPtr Orientation::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "setIdentity();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Orientation::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeOrientation(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Orientation::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray({1, 4, 4}, \"float\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data())); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Orientation::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr Orientation::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7f5f6586cd1c34ba5f3da256ddd926adce91cd1
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Orientation.h
@@ -0,0 +1,50 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Orientation :
+ public detail::NDArrayGenerator<type::Orientation, Orientation>
+ {
+ public:
+
+ // constructors
+ Orientation(const type::Orientation&);
+ virtual ~Orientation() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string&) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string& cppAccessor, const std::string&) const override;
+
+ };
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ee8b76e58fb9f9ce34bb421150d58a8d5f9568a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.cpp
@@ -0,0 +1,111 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PointCloud.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+
+ const std::map<type::pointcloud::VoxelType, std::pair<std::string, int>> PointCloud::VoxelType2Cpp =
+ {
+ // see http://docs.ros.org/en/groovy/api/pcl/html/point__types_8hpp_source.html
+ {type::pointcloud::VoxelType::PointXYZ, {"pcl::PointXYZ", 16}},
+ {type::pointcloud::VoxelType::PointXYZI, {"pcl::PointXYZI", 32}},
+ {type::pointcloud::VoxelType::PointXYZL, {"pcl::PointXYZL", 32}},
+ {type::pointcloud::VoxelType::PointXYZRGB, {"pcl::PointXYZRGB", 32}},
+ {type::pointcloud::VoxelType::PointXYZRGBL, {"pcl::PointXYZRGBL", 32}},
+ {type::pointcloud::VoxelType::PointXYZRGBA, {"pcl::PointXYZRGBA", 32}},
+ {type::pointcloud::VoxelType::PointXYZHSV, {"pcl::PointXYZHSV", 32}}
+ };
+
+ // constructors
+ PointCloud::PointCloud(const type::PointCloud& n) :
+ detail::NDArrayGenerator<type::PointCloud, PointCloud>(
+ "pcl::PointCloud<" + VoxelType2Cpp.at(n.getVoxelType()).first + ">",
+ simox::meta::get_type_name<data::dto::NDArray>(),
+ simox::meta::get_type_name<type::dto::PointCloud>(),
+ n)
+ {
+ }
+
+ CppBlockPtr PointCloud::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + " = " + getFullCppTypename() + "(" + cppAccessor + nextEl() + "width, " + cppAccessor + nextEl() + "height);");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr PointCloud::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writePointCloud(" + conversion::VoxelType2CppString.at(type.getVoxelType()) + ", " + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr PointCloud::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray({" + cppAccessor + nextEl() + "width, " + cppAccessor + nextEl() + "height, " + std::to_string(VoxelType2Cpp.at(type.getVoxelType()).second) + "}, \"" + VoxelType2Cpp.at(type.getVoxelType()).first + "\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "points.data())); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr PointCloud::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine(cppAccessor + " = " + getCoreCppTypename() + "(" + dims + "[0], " + dims + "[1]);");
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "points.data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr PointCloud::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (" + accessor + nextEl() + "width != " + otherInstanceAccessor + nextEl() + "width || " + accessor + nextEl() + "height != " + otherInstanceAccessor + nextEl() + "height)");
+ block_if_data->addLineAsBlock("return false;");
+
+ //block_if_data->addLine("if (" + accessor + nextEl() + "points != " + otherInstanceAccessor + nextEl() + "points)");
+ //block_if_data->addLine("\t return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb267a9669edc44eee1d79df4e4344e454e76cae
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.h
@@ -0,0 +1,52 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h>
+
+#include <map>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class PointCloud :
+ public detail::NDArrayGenerator<type::PointCloud, PointCloud>
+ {
+ public:
+ // constructors
+ PointCloud(const type::PointCloud&);
+ virtual ~PointCloud() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string& cppAccessor, const std::string&) const override;
+
+ public:
+ static const std::map<type::pointcloud::VoxelType, std::pair<std::string, int>> VoxelType2Cpp;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21ecd910edc0b6e06a9aa9d61a7969ba2798c2d0
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.cpp
@@ -0,0 +1,94 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Pose.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ Pose::Pose(const type::Pose& n) :
+ detail::NDArrayGenerator<type::Pose, Pose>(
+ "Eigen::Matrix<float, 4, 4>",
+ simox::meta::get_type_name<data::dto::NDArray>(),
+ simox::meta::get_type_name<type::dto::Pose>(),
+ n)
+ {
+ }
+
+ CppBlockPtr Pose::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "setIdentity();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Pose::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writePose(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Pose::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray({4, 4, 4}, \"float\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "data())); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Pose::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr Pose::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.h
new file mode 100644
index 0000000000000000000000000000000000000000..b684debf1bb8d143004b93be4b21ba07e34ae8f7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Pose.h
@@ -0,0 +1,48 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Pose :
+ public detail::NDArrayGenerator<type::Pose, Pose>
+ {
+ public:
+ // constructors
+ Pose(const type::Pose&);
+ virtual ~Pose() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string& cppAccessor, const std::string&) const override;
+
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6724244b9e3b676511ced176844f94b07669133b
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.cpp
@@ -0,0 +1,94 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Position.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ Position::Position(const type::Position& n) :
+ detail::NDArrayGenerator<type::Position, Position>(
+ "Eigen::Matrix<float, 3, 1>",
+ simox::meta::get_type_name<data::dto::NDArray>(),
+ simox::meta::get_type_name<type::dto::Position>(),
+ n)
+ {
+ }
+
+ CppBlockPtr Position::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "setZero();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Position::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writePosition(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Position::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray({3, 1, 4}, \"float\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "data())); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Position::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr Position::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.h
new file mode 100644
index 0000000000000000000000000000000000000000..28021af44afdb2fd45398e84f443cd9c86b6cfb7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Position.h
@@ -0,0 +1,48 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Position.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Position :
+ public detail::NDArrayGenerator<type::Position, Position>
+ {
+ public:
+ // constructors
+ Position(const type::Position&);
+ virtual ~Position() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string& cppAccessor, const std::string&) const override;
+
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e945e3040b2ce3c241832355b62e1e58abe709a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp
@@ -0,0 +1,100 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Quaternion.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+
+ const std::map<type::quaternion::ElementType, std::pair<std::string, int>> Quaternion::ElementType2Cpp =
+ {
+ {type::quaternion::ElementType::float32, {"float", 4}},
+ {type::quaternion::ElementType::float64, {"double", 8}}
+ };
+
+ // constructors
+ Quaternion::Quaternion(const type::Quaternion& n) :
+ detail::NDArrayGenerator<type::Quaternion, Quaternion>(
+ "Eigen::Quaternion<" + ElementType2Cpp.at(n.getElementType()).first + ">",
+ simox::meta::get_type_name<data::dto::NDArray>(),
+ simox::meta::get_type_name<type::dto::Quaternion>(),
+ n)
+ {
+ }
+
+ CppBlockPtr Quaternion::getResetSoftBlock(const std::string& cppAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine(cppAccessor + nextEl() + "setIdentity();");
+ return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Quaternion::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeQuaternion(" + conversion::QuaternionElementType2Cpp.at(type.getElementType()) + ", " + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + cppAccessor);
+ return b;
+ }
+
+ CppBlockPtr Quaternion::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writeNDArray({1, 4, " + std::to_string(ElementType2Cpp.at(type.getElementType()).second) + "}, \"" + ElementType2Cpp.at(type.getElementType()).first + "\", reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data())); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Quaternion::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string type = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_typeAsString";
+ std::string dims = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_shape";
+ std::string data = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor + "_data";
+
+ block_if_data->addLine("std::string " + type + ";");
+ block_if_data->addLine("std::vector<int> " + dims + ";");
+ block_if_data->addLine("std::vector<unsigned char> " + data + ";");
+ block_if_data->addLine("r.readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
+ block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data()), "+data+".data(), "+data+".size());");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
+ }
+
+ CppBlockPtr Quaternion::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.h
new file mode 100644
index 0000000000000000000000000000000000000000..c552274d3f39b21abe10f5cbca8dcadf7a93f074
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h>
+
+#include <map>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Quaternion :
+ public detail::NDArrayGenerator<type::Quaternion, Quaternion>
+ {
+ public:
+ // constructors
+ Quaternion(const type::Quaternion&);
+ virtual ~Quaternion() = default;
+
+ // virtual implementations
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
+
+ public:
+ static const std::map<type::quaternion::ElementType, std::pair<std::string, int>> ElementType2Cpp;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d0df90fb84d8299b16b20f1ba467a10aa59c926
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/All.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Int.h"
+#include "Long.h"
+#include "Float.h"
+#include "Double.h"
+#include "String.h"
+#include "Bool.h"
+#include "Time.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.cpp
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.cpp
index 33283bde524169ec20e01bd659de94547b662212..f4e669fafd19dd1d42be56e2782bcc8f067d5c49 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Bool.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.cpp
@@ -26,24 +26,22 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- BoolSerializer::BoolSerializer(const typenavigator::BoolNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::BoolNavigator, BoolSerializer>(
- "bool",
- simox::meta::get_type_name<data::AronBool>(),
- simox::meta::get_type_name<type::AronBool>(),
- e)
+ Bool::Bool(const type::Bool& e) :
+ detail::PrimitiveGenerator<type::Bool, Bool>("bool", simox::meta::get_type_name<data::dto::AronBool>(), simox::meta::get_type_name<type::dto::AronBool>(), e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr BoolSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr Bool::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeBool({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeBool(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d668108313decbdaae9fd292c7b2c59ce5ed8b5
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Bool.h
@@ -0,0 +1,44 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "../detail/PrimitiveGenerator.h"
+
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Bool.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Bool :
+ public detail::PrimitiveGenerator<type::Bool, Bool>
+ {
+ public:
+ /* constructors */
+ Bool(const type::Bool& e);
+ virtual ~Bool() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.cpp
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.cpp
index c7bbce2eebe2367b83ce5d63a4b7b77b1da7acc6..efc7fce95604bf7016121d184637143bd706b0ad 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.cpp
@@ -26,24 +26,26 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- DoubleSerializer::DoubleSerializer(const typenavigator::DoubleNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::DoubleNavigator, DoubleSerializer>(
+ Double::Double(const type::Double& e) :
+ detail::PrimitiveGenerator<type::Double, Double>(
"double",
- simox::meta::get_type_name<data::AronDouble>(),
- simox::meta::get_type_name<type::AronDouble>(),
+ simox::meta::get_type_name<data::dto::AronDouble>(),
+ simox::meta::get_type_name<type::dto::AronDouble>(),
e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr DoubleSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr Double::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeDouble({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeDouble(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e7f5758947f6879f1a680e8086f5bbf33ab5b8e
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Double.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Double.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Double :
+ public detail::PrimitiveGenerator<type::Double, Double>
+ {
+ public:
+ /* constructors */
+ Double(const type::Double& e);
+ virtual ~Double() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.cpp
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.cpp
index 34593db2f5b0b7fd7113395d79233b2a9c93b6d4..c82c4ec16f2e0f0e7c20ebec74de930aea315492 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Float.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.cpp
@@ -26,24 +26,26 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- FloatSerializer::FloatSerializer(const typenavigator::FloatNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::FloatNavigator, FloatSerializer>(
+ Float::Float(const type::Float& e) :
+ detail::PrimitiveGenerator<type::Float, Float>(
"float",
- simox::meta::get_type_name<data::AronFloat>(),
- simox::meta::get_type_name<type::AronFloat>(),
+ simox::meta::get_type_name<data::dto::AronFloat>(),
+ simox::meta::get_type_name<type::dto::AronFloat>(),
e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr FloatSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr Float::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeFloat({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeFloat(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2fd86a8e2fed7ec29270a62e66f045b4c453920
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Float.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Float.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Float :
+ public detail::PrimitiveGenerator<type::Float, Float>
+ {
+ public:
+ /* constructors */
+ Float(const type::Float& e);
+ virtual ~Float() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.cpp
similarity index 60%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.cpp
index 84299f5843002d822eae0845f748a9ecf4e491f9..0b7409bd3f62717b45d057362befc76236142f18 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Int.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.cpp
@@ -26,24 +26,26 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- IntSerializer::IntSerializer(const typenavigator::IntNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::IntNavigator, IntSerializer>(
+ Int::Int(const type::Int& e) :
+ detail::PrimitiveGenerator<type::Int, Int>(
"int",
- simox::meta::get_type_name<data::AronInt>(),
- simox::meta::get_type_name<type::AronInt>(),
+ simox::meta::get_type_name<data::dto::AronInt>(),
+ simox::meta::get_type_name<type::dto::AronInt>(),
e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr IntSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr Int::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeInt({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeInt(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.h
new file mode 100644
index 0000000000000000000000000000000000000000..de61c2786aaef3bbc2871f24feb9d5723093b731
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Int.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Int.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Int :
+ public detail::PrimitiveGenerator<type::Int, Int>
+ {
+ public:
+ /* constructors */
+ Int(const type::Int& e);
+ virtual ~Int() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.cpp
similarity index 60%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.cpp
index 2d6f466342a6747688180245f2892284ea956196..78e2e24fd7b208d1dc51368ae710ad65c6208ba8 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Long.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.cpp
@@ -26,24 +26,26 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- LongSerializer::LongSerializer(const typenavigator::LongNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::LongNavigator, LongSerializer>(
+ Long::Long(const type::Long& e) :
+ detail::PrimitiveGenerator<type::Long, Long>(
"long",
- simox::meta::get_type_name<data::AronLong>(),
- simox::meta::get_type_name<type::AronLong>(),
+ simox::meta::get_type_name<data::dto::AronLong>(),
+ simox::meta::get_type_name<type::dto::AronLong>(),
e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr LongSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr Long::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeLong({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeLong(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.h
new file mode 100644
index 0000000000000000000000000000000000000000..265f1c1cee1af5c5e08a1736ff54ef7efb149a3a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Long.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Long.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class Long :
+ public detail::PrimitiveGenerator<type::Long, Long>
+ {
+ public:
+ /* constructors */
+ Long(const type::Long& e);
+ virtual ~Long() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.cpp
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.cpp
index 4246e1157739f62934d58f1037dcc4098aa52fdc..c656875f307a87fc0f86f4035148d28a55f64247 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/String.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.cpp
@@ -26,24 +26,26 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
- StringSerializer::StringSerializer(const typenavigator::StringNavigatorPtr& e) :
- detail::PrimitiveSerializerBase<typenavigator::StringNavigator, StringSerializer>(
+ String::String(const type::String& e) :
+ detail::PrimitiveGenerator<type::String, String>(
"std::string",
- simox::meta::get_type_name<data::AronString>(),
- simox::meta::get_type_name<type::AronString>(),
+ simox::meta::get_type_name<data::dto::AronString>(),
+ simox::meta::get_type_name<type::dto::AronString>(),
e)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
}
/* virtual implementations */
- CppBlockPtr StringSerializer::getWriteTypeBlock(const std::string& accessor) const
+ CppBlockPtr String::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeString({" + MAYBE_TO_STRING(typenavigator->getMaybe()) + "}); // of " + accessor);
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeString(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
return b;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e795d06efd6ff8467cb841841ede82d56ec7313
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/String.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/String.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class String :
+ public detail::PrimitiveGenerator<type::String, String>
+ {
+ public:
+ /* constructors */
+ String(const type::String& e);
+ virtual ~String() = default;
+
+ /* virtual implementations */
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37601a62d8554dc3d2d38d8e0d16a39be8a55728
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.cpp
@@ -0,0 +1,76 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Time.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ /* constructors */
+ Time::Time(const type::Time& e) :
+ detail::PrimitiveGenerator<type::Time, Time>(
+ "IceUtil::Time",
+ simox::meta::get_type_name<data::dto::AronLong>(),
+ simox::meta::get_type_name<type::dto::AronTime>(),
+ e)
+ {
+ }
+
+ /* virtual implementations */
+ CppBlockPtr Time::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(accessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ b->addLine("auto " + variantAccessor + " = w.writeTime(" + conversion::Maybe2CppString.at(type.getMaybe()) + "); // of " + accessor);
+ return b;
+ }
+
+ CppBlockPtr Time::getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
+
+ block_if_data->addLine(variantAccessor + " = w.writePrimitive(" + cppAccessor + nextEl() + "toMicroSeconds()); // of " + cppAccessor);
+
+ return resolveMaybeWriteBlock(block_if_data, cppAccessor);
+ }
+
+ CppBlockPtr Time::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ std::string escaped_accessor = EscapeAccessor(cppAccessor);
+ std::string resolved_accessor = resolveMaybeAccessor(cppAccessor);
+ std::string tmp = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_timeTmp";
+
+ block_if_data->addLine("long " + tmp + ";");
+ block_if_data->addLine("r.readPrimitive("+variantAccessor+", " + tmp + "); // of " + cppAccessor);
+ block_if_data->addLine(resolved_accessor + " = IceUtil::Time::microSeconds(" + tmp + ");");
+ return resolveMaybeReadBlock(block_if_data, cppAccessor, cppAccessor);
+ }
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.h
similarity index 57%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.h
index b8258a0b028ac020c61af412d402599367587e6a..a56233e1ae1b79cb35e40b51781524aacff4a725 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Double.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/primitive/Time.h
@@ -23,23 +23,23 @@
#pragma once
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Double.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Time.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
- class DoubleSerializer;
- typedef std::shared_ptr<DoubleSerializer> DoubleSerializerPtr;
-
- class DoubleSerializer :
- virtual public detail::PrimitiveSerializerBase<typenavigator::DoubleNavigator, DoubleSerializer>
+ class Time :
+ public detail::PrimitiveGenerator<type::Time, Time>
{
public:
/* constructors */
- DoubleSerializer(const typenavigator::DoubleNavigatorPtr& e);
+ Time(const type::Time& e);
+ virtual ~Time() = default;
/* virtual implementations */
- virtual CppBlockPtr getWriteTypeBlock(const std::string& accessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/All.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..310538fe36bf8db207f3bb04eb3e9ab1cb2d03ac
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/All.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "IntEnumClass.h"
+#include "ObjectClass.h"
+
+namespace {
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp
similarity index 69%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.cpp
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp
index 5f3c8043a69376538f41f8a55313b53f0c331f80..f7f8d836f3e3cf1c6fec54a2e97aa11d7aceae25 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp
@@ -27,24 +27,23 @@
#include <SimoxUtility/meta/type_name.h>
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
// constructors
- IntEnumClassSerializer::IntEnumClassSerializer(const typenavigator::IntEnumNavigatorPtr& n) :
- detail::SerializerBase<typenavigator::IntEnumNavigator, IntEnumClassSerializer>(
- n->getEnumName(),
- simox::meta::get_type_name<data::AronNDArray>(),
- simox::meta::get_type_name<type::AronIntEnum>(),
+ IntEnumClass::IntEnumClass(const type::IntEnum& n) :
+ detail::SpecializedGeneratorBase<type::IntEnum, IntEnumClass>(
+ n.getEnumName(),
+ simox::meta::get_type_name<data::dto::NDArray>(),
+ simox::meta::get_type_name<type::dto::IntEnum>(),
n)
{
- ARMARX_CHECK_NOT_NULL(typenavigator);
- if (typenavigator->getMaybe() != type::Maybe::eNone)
+ if (type.getMaybe() != type::Maybe::eNone)
{
- throw error::MaybeNotValidException("IntEnumClassSerializer", "IntEnumClassSerializer", "Somehow the maybe flag of a top level int enum declaration is set. This is not valid!", typenavigator->getMaybe(), typenavigator->getPath());
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Somehow the maybe flag of a top level int enum declaration is set. This is not valid!", std::to_string((int) type.getMaybe()), type.getPath());
}
}
- std::vector<CppFieldPtr> IntEnumClassSerializer::getPublicVariableDeclarations(const std::string&) const
+ std::vector<CppFieldPtr> IntEnumClass::getPublicVariableDeclarations(const std::string&) const
{
std::vector<CppFieldPtr> fields;
std::stringstream enum_to_name;
@@ -56,7 +55,7 @@ namespace armarx::aron::cppserializer::serializer
name_to_enum << "{" << std::endl;
enum_to_value << "{" << std::endl;
value_to_enum << "{" << std::endl;
- for (const auto& [key, value] : typenavigator->getAcceptedValueMap())
+ for (const auto& [key, value] : type.getAcceptedValueMap())
{
std::string enumKeyWithNamespace = std::string(IMPL_ENUM) + "::" + key;
fields.push_back(std::make_shared<CppField>("static constexpr " + std::string(IMPL_ENUM), key + " = " + enumKeyWithNamespace));
@@ -83,53 +82,62 @@ namespace armarx::aron::cppserializer::serializer
return fields;
}
- CppBlockPtr IntEnumClassSerializer::getResetSoftBlock(const std::string& accessor) const
+ CppBlockPtr IntEnumClass::getResetSoftBlock(const std::string& accessor) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("value = {};");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
+ return block_if_data;
}
- CppBlockPtr IntEnumClassSerializer::getResetHardBlock(const std::string& accessor) const
+ CppBlockPtr IntEnumClass::getResetHardBlock(const std::string& accessor) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("value = {};");
- return ResolveMaybeResetSoftBlock(accessor, block_if_data, typenavigator);
+ return block_if_data;
}
- CppBlockPtr IntEnumClassSerializer::getWriteTypeBlock(const std::string&) const
+ CppBlockPtr IntEnumClass::getWriteTypeBlock(const std::string&, const std::string&, std::string&) const
{
- CppBlockPtr b = CppBlockPtr(new CppBlock());
- b->addLine("w.writeInt({__aronMaybeType}); // of top level enum " + getCoreCppTypename());
+ static const std::string INT_ENUM_VALUE_MAP = ARON_VARIABLE_PREFIX + "_str2ValueMap";
+
+ CppBlockPtr b = std::make_shared<CppBlock>();
+
+ b->addLine("//TODO: ");
+ b->addLine("std::map<std::string, int> " + INT_ENUM_VALUE_MAP + ";");
+ b->addLine("return w.writeIntEnum(\"" + type.getEnumName() + "\", "+INT_ENUM_VALUE_MAP+", "+ ARON_MAYBE_TYPE_ACCESSOR + ");");
+ return b;
+
return b;
}
- CppBlockPtr IntEnumClassSerializer::getWriteBlock(const std::string& accessor) const
+ CppBlockPtr IntEnumClass::getWriteBlock(const std::string&, std::string&) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("w.writePrimitive(EnumToValueMap.at(value)); // of top level enum " + getCoreCppTypename());
- return ResolveMaybeWriteBlock(accessor, block_if_data, typenavigator);
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("return w.writePrimitive(EnumToValueMap.at(value)); // of top level enum " + getCoreCppTypename());
+ return block_if_data;
}
- CppBlockPtr IntEnumClassSerializer::getReadBlock(const std::string& accessor) const
+ CppBlockPtr IntEnumClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
- block_if_data->addLine("int temporary;");
- block_if_data->addLine("r.readEndPrimitive(temporary); // of top level enum " + getCoreCppTypename());
- block_if_data->addLine("value = ValueToEnumMap.at(temporary);");
- return ResolveMaybeReadBlock(accessor, "r.readStartPrimitive()", block_if_data, typenavigator);
+ static const std::string INT_ENUM_TMP_VALUE = ARON_VARIABLE_PREFIX + "_tmpValue";
+
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("int " + INT_ENUM_TMP_VALUE + ";");
+ block_if_data->addLine("r.readPrimitive("+variantAccessor+", "+INT_ENUM_TMP_VALUE+"); // of top level enum " + getCoreCppTypename());
+ block_if_data->addLine("value = ValueToEnumMap.at("+INT_ENUM_TMP_VALUE+");");
+ return block_if_data;
}
- CppBlockPtr IntEnumClassSerializer::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ CppBlockPtr IntEnumClass::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
{
- CppBlockPtr block_if_data = CppBlockPtr(new CppBlock());
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("if (not (value == " + otherInstanceAccessor + ".value))");
block_if_data->addLineAsBlock("return false;");
- return ResolveMaybeEqualsBlock(accessor, otherInstanceAccessor, block_if_data, typenavigator);
+ return block_if_data;
}
- CppCtorPtr IntEnumClassSerializer::toCopyCtor(const std::string& name) const
+ CppCtorPtr IntEnumClass::toCopyCtor(const std::string& name) const
{
CppCtorPtr c = std::make_shared<CppCtor>(name + "(const " + getFullCppTypename() + "& i)");
std::vector<std::pair<std::string, std::string>> initList = {{"value", "i.value"}};
@@ -137,7 +145,7 @@ namespace armarx::aron::cppserializer::serializer
return c;
}
- CppCtorPtr IntEnumClassSerializer::toInnerEnumCtor(const std::string& name) const
+ CppCtorPtr IntEnumClass::toInnerEnumCtor(const std::string& name) const
{
CppCtorPtr c = std::make_shared<CppCtor>(name + "(const " + std::string(IMPL_ENUM) + " e)");
std::vector<std::pair<std::string, std::string>> initList = {{"value", "e"}};
@@ -145,17 +153,17 @@ namespace armarx::aron::cppserializer::serializer
return c;
}
- CppEnumPtr IntEnumClassSerializer::toInnerEnumDefinition() const
+ CppEnumPtr IntEnumClass::toInnerEnumDefinition() const
{
CppEnumPtr e = std::make_shared<CppEnum>(std::string(IMPL_ENUM), "The internal enum definition of the enum of this autogenerated class.");
- for (const auto& [key, value] : typenavigator->getAcceptedValueMap())
+ for (const auto& [key, value] : type.getAcceptedValueMap())
{
e->addField(std::make_shared<CppEnumField>(key));
}
return e;
}
- CppMethodPtr IntEnumClassSerializer::toIntMethod() const
+ CppMethodPtr IntEnumClass::toIntMethod() const
{
std::stringstream doc;
doc << "@brief int() - Converts the internally stored value to int representation \n";
@@ -168,7 +176,7 @@ namespace armarx::aron::cppserializer::serializer
return m;
}
- CppMethodPtr IntEnumClassSerializer::toCopyAssignmentMethod() const
+ CppMethodPtr IntEnumClass::toCopyAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for copy \n";
@@ -182,7 +190,7 @@ namespace armarx::aron::cppserializer::serializer
return m;
}
- CppMethodPtr IntEnumClassSerializer::toEnumAssignmentMethod() const
+ CppMethodPtr IntEnumClass::toEnumAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for the internally defined enum \n";
@@ -196,7 +204,7 @@ namespace armarx::aron::cppserializer::serializer
return m;
}
- CppMethodPtr IntEnumClassSerializer::toIntAssignmentMethod() const
+ CppMethodPtr IntEnumClass::toIntAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for the internally defined enum \n";
@@ -217,7 +225,7 @@ namespace armarx::aron::cppserializer::serializer
return m;
}
- CppMethodPtr IntEnumClassSerializer::toToStringMethod() const
+ CppMethodPtr IntEnumClass::toToStringMethod() const
{
std::stringstream doc;
doc << "@brief toString() - Converts the internally stored value to string \n";
@@ -230,7 +238,7 @@ namespace armarx::aron::cppserializer::serializer
return m;
}
- CppMethodPtr IntEnumClassSerializer::toFromStringMethod() const
+ CppMethodPtr IntEnumClass::toFromStringMethod() const
{
std::stringstream doc;
doc << "@brief fromString() - sets the internally stored value to the corrsponding enum of the input str \n";
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h
similarity index 64%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h
index 4a73767f0f800f03be6c1d77759ba17993cac1a3..ce3ac5c9622a99c15b1a5ca16f9b9076999e2702 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h
@@ -23,34 +23,31 @@
#pragma once
-#include <RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
#include <map>
#include <utility> // std::pair
-namespace armarx::aron::cppserializer::serializer
+namespace armarx::aron::codegenerator::cpp::generator
{
-
- class IntEnumClassSerializer;
- typedef std::shared_ptr<IntEnumClassSerializer> IntEnumClassSerializerPtr;
-
- class IntEnumClassSerializer :
- virtual public detail::SerializerBase<typenavigator::IntEnumNavigator, IntEnumClassSerializer>
+ class IntEnumClass :
+ public detail::SpecializedGeneratorBase<type::IntEnum, IntEnumClass>
{
public:
// constructors
- IntEnumClassSerializer(const typenavigator::IntEnumNavigatorPtr&);
+ IntEnumClass(const type::IntEnum&);
+ virtual ~IntEnumClass() = default;
// virtual implementations
- std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const;
- virtual CppBlockPtr getResetHardBlock(const std::string&) const override;
- virtual CppBlockPtr getResetSoftBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteTypeBlock(const std::string&) const override;
- virtual CppBlockPtr getWriteBlock(const std::string&) const override;
- virtual CppBlockPtr getReadBlock(const std::string&) const override;
- virtual CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
+ std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const override;
+ CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const override;
+ CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
// TODO: Move some of those methods to upper class for enums (if we want to support multiple enums)
CppCtorPtr toCopyCtor(const std::string&) const;
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c99e7ef917baed5550d5e22aaa8ffb85b66634f2
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.cpp
@@ -0,0 +1,202 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "ObjectClass.h"
+
+#include <SimoxUtility/meta/type_name.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ // constructors
+ ObjectClass::ObjectClass(const type::Object& e) :
+ detail::SpecializedGeneratorBase<type::Object, ObjectClass>(e.getObjectName(), simox::meta::get_type_name<data::dto::Dict>(), simox::meta::get_type_name<type::dto::AronObject>(), e)
+ {
+ if (type.getMaybe() != type::Maybe::eNone)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Somehow the maybe flag of a top level object declaration is set. This is not valid!", std::to_string((int) type.getMaybe()) + " aka " + type::defaultconversion::string::Maybe2String.at(type.getMaybe()), type.getPath());
+ }
+ }
+
+ std::vector<CppFieldPtr> ObjectClass::getPublicVariableDeclarations(const std::string&) const
+ {
+ std::vector<CppFieldPtr> fields;
+ for (const auto& [key, member] : type.getMemberTypes())
+ {
+ auto member_s = FromAronType(*member);
+ std::vector<CppFieldPtr> member_fields = member_s->getPublicVariableDeclarations(key);
+ fields.insert(fields.end(), member_fields.begin(), member_fields.end());
+ }
+ return fields;
+ }
+
+ CppBlockPtr ObjectClass::getResetSoftBlock(const std::string& accessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ block_if_data->addLine(extends_s->getFullCppTypename() + "::resetSoft();");
+ }
+
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ auto child_s = FromAronType(*child);
+ CppBlockPtr b2 = child_s->getResetSoftBlock(key);
+ block_if_data->appendBlock(b2);
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr ObjectClass::getResetHardBlock(const std::string& accessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ block_if_data->addLine(extends_s->getFullCppTypename() + "::resetHard();");
+ }
+
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ const auto child_s = FromAronType(*child);
+ CppBlockPtr b2 = child_s->getResetHardBlock(key);
+ block_if_data->appendBlock(b2);
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr ObjectClass::getWriteTypeBlock(const std::string&, const std::string&, std::string&) const
+ {
+ static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
+ static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
+
+ CppBlockPtr b = std::make_shared<CppBlock>();
+ b->addLine("std::map<std::string, T> " + OBJECT_MEMBERS_ACCESSOR + ";");
+
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ b->addLine("// get base class of " + this->getFullCppTypename());
+ b->addLine("auto " + OBJECT_EXTENDS_ACCESSOR + " = " + extends_s->getFullCppTypename() + "::writeType(w, ::armarx::aron::type::Maybe::eNone);");
+ }
+
+ b->addLine("// members of " + this->getFullCppTypename());
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ const auto child_s = FromAronType(*child);
+ std::string child_return_variant;
+ CppBlockPtr child_b = child_s->getWriteTypeBlock(child_s->getFullCppTypename(), key, child_return_variant);
+ b->appendBlock(child_b);
+ b->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " + child_return_variant + ");");
+ }
+
+ if (type.getExtends() != nullptr)
+ {
+ b->addLine("return w.writeObject(\"" + type.getObjectName() + "\", "+ARON_MAYBE_TYPE_ACCESSOR+", " + OBJECT_MEMBERS_ACCESSOR + ", " + OBJECT_EXTENDS_ACCESSOR + ");");
+ }
+ else
+ {
+ b->addLine("return w.writeObject(\"" + type.getObjectName() + "\", "+ARON_MAYBE_TYPE_ACCESSOR+", " + OBJECT_MEMBERS_ACCESSOR + ", std::nullopt);");
+ }
+
+ return b;
+ }
+
+ CppBlockPtr ObjectClass::getWriteBlock(const std::string&, std::string&) const
+ {
+ static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
+ static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
+
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+
+ block_if_data->addLine("std::map<std::string, T> " + OBJECT_MEMBERS_ACCESSOR + ";");
+
+ block_if_data->addLine("std::optional<T> " + OBJECT_EXTENDS_ACCESSOR + ";");
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ block_if_data->addLine("// write base class of " + this->getFullCppTypename());
+ block_if_data->addLine(OBJECT_EXTENDS_ACCESSOR + " = " + extends_s->getFullCppTypename() + "::write(w);");
+ }
+
+ block_if_data->addLine("// members of " + this->getFullCppTypename());
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ const auto child_s = FromAronType(*child);
+ std::string child_return_variant;
+ CppBlockPtr child_b = child_s->getWriteBlock(key, child_return_variant);
+ block_if_data->addLine("auto " + child_return_variant + " = w.writeNull();");
+ block_if_data->appendBlock(child_b);
+ block_if_data->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " + child_return_variant + ");");
+ }
+
+ block_if_data->addLine("return w.writeDict("+OBJECT_MEMBERS_ACCESSOR+", " + OBJECT_EXTENDS_ACCESSOR + "); // of top level object " + getCoreCppTypename());
+ return block_if_data;
+ }
+
+ CppBlockPtr ObjectClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
+ {
+ static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
+ static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
+
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ block_if_data->addLine("std::map<std::string, TNonConst> " + OBJECT_MEMBERS_ACCESSOR + ";");
+
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ block_if_data->addLine(extends_s->getFullCppTypename() + "::read(r, "+variantAccessor+");");
+ }
+
+ block_if_data->addLine("r.readDict("+variantAccessor+", "+OBJECT_MEMBERS_ACCESSOR+"); // of top level object " + getCoreCppTypename());
+
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ const auto child_s = FromAronType(*child);
+ const std::string child_variant_accessor = OBJECT_MEMBERS_ACCESSOR + ".at(\"" + key + "\")";
+ block_if_data->appendBlock(child_s->getReadBlock(key, child_variant_accessor));
+ }
+ return block_if_data;
+ }
+
+ CppBlockPtr ObjectClass::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
+ {
+ CppBlockPtr block_if_data = std::make_shared<CppBlock>();
+ if (type.getExtends() != nullptr)
+ {
+ const auto extends_s = FromAronType(*type.getExtends());
+ block_if_data->addLine("if (not (" + extends_s->getFullCppTypename() + "::operator== (" + otherInstanceAccessor + ")))");
+ block_if_data->addLineAsBlock("return false;");
+ }
+ for (const auto& [key, child] : type.getMemberTypes())
+ {
+ auto child_s = FromAronType(*child);
+ CppBlockPtr b2 = child_s->getEqualsBlock(key, otherInstanceAccessor + "." + key);
+ block_if_data->appendBlock(b2);
+ }
+ return block_if_data;
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h
new file mode 100644
index 0000000000000000000000000000000000000000..56ccc97a86c77b71b1a99eb0820056ece18a9dbd
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h
@@ -0,0 +1,49 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+
+
+namespace armarx::aron::codegenerator::cpp::generator
+{
+ class ObjectClass :
+ public detail::SpecializedGeneratorBase<type::Object, ObjectClass>
+ {
+ public:
+ // constructors
+ ObjectClass(const type::Object&);
+ virtual ~ObjectClass() = default;
+
+ // virtual implementations
+ std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const override;
+ CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const override;
+ CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, std::string& variantAccessor) const override;
+ CppBlockPtr getWriteBlock(const std::string& cppAccessor, std::string&) const override;
+ CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string&) const override;
+ CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h b/source/RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h
similarity index 82%
rename from source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h
index f66bc8566c1dc16158e4bdc8aed3ec78d8222362..a025da99a26a9538f53306ce9ba96d1fb8396ad5 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h
@@ -27,17 +27,22 @@
#include <memory>
#include <string>
-namespace armarx::aron::codegeneratorhelper
+namespace armarx::aron::codegenerator
{
- class ReaderInfo;
- typedef std::shared_ptr<ReaderInfo> ReaderInfoPtr;
-
- class ReaderInfo
+ struct ReaderInfo
{
- public:
std::string methodName;
std::string argumentType;
std::string readerClassType;
std::string include;
+ std::string enforceConversion = "";
+ };
+
+
+ struct StaticReaderInfo
+ {
+ std::string methodName;
+ std::string argumentType;
+ std::string returnType;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h b/source/RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h
similarity index 88%
rename from source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h
rename to source/RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h
index a9d99d424959ca94f454005a9663fc51e78ecfe0..33090bcbe0a07d6e9c8f5f124905e13424945ec3 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h
@@ -27,14 +27,10 @@
#include <memory>
#include <string>
-namespace armarx::aron::codegeneratorhelper
+namespace armarx::aron::codegenerator
{
- class WriterInfo;
- typedef std::shared_ptr<WriterInfo> WriterInfoPtr;
-
- class WriterInfo
+ struct WriterInfo
{
- public:
std::string methodName;
std::string returnType;
std::string writerClassType;
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.cpp
deleted file mode 100644
index a593bad8cf3d2b9b2a08af3adc10ae478f56cf87..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include "Data.h"
-
-#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
-
-#include <SimoxUtility/algorithm/string/string_tools.h>
-
-namespace armarx::aron::xmltypereader
-{
-
- void Data::EnforceAttribute(const RapidXmlReaderNode& node, const std::string& att)
- {
- if (!HasAttribute(node, att))
- {
- throw error::StringNotValidException("XMLReaderData", "EnforceAttribute", "A <" + node.name() + ">-tag does not have the correct attribute", att);
- }
- }
-
- bool Data::HasAttribute(const RapidXmlReaderNode& node, const std::string& att)
- {
- return node.has_attribute(att.c_str());
- }
-
- std::string Data::GetAttribute(const RapidXmlReaderNode& node, const std::string& att)
- {
- EnforceAttribute(node, att);
- return node.attribute_value(att.c_str());
- }
-
- std::string Data::GetAttributeWithDefault(const armarx::RapidXmlReaderNode& node, const std::string& att, const std::string def)
- {
- if (!(HasAttribute(node, att)))
- {
- return def;
- }
- return node.attribute_value(att.c_str());
- }
-
- bool Data::AttributeIsTrue(const armarx::RapidXmlReaderNode& node, const std::string& att)
- {
- if (HasAttribute(node, att))
- {
- std::string v = simox::alg::to_lower(node.attribute_value(att.c_str()));
- if (v == "1" or v == "true" or v == "wahr" or v == "yes" or v == "ja" or v == "")
- {
- return true;
- }
- }
- return false;
- }
-
- bool Data::HasTagName(const armarx::RapidXmlReaderNode& node, const std::string& name)
- {
- return (simox::alg::to_lower(name) == simox::alg::to_lower(node.name()));
- }
-
- void Data::EnforceTagName(const armarx::RapidXmlReaderNode& node, const std::string& name)
- {
- if (!(HasTagName(node, name)))
- {
- throw error::StringNotValidException("XMLReaderData", "EnforceTagName", "The node <" + node.name() + "> has the wrong tag", name);
- }
- }
-
- std::string Data::GetTagName(const armarx::RapidXmlReaderNode& node)
- {
- return simox::alg::to_lower(node.name());
- }
-
- bool Data::CheckMinChildSize(const armarx::RapidXmlReaderNode& node, const size_t size)
- {
- std::vector<RapidXmlReaderNode> children = node.nodes();
- return children.size() >= size;
- }
-
- bool Data::CheckMaxChildSize(const armarx::RapidXmlReaderNode& node, const size_t size)
- {
- std::vector<RapidXmlReaderNode> children = node.nodes();
- return children.size() <= size;
- }
-
- bool Data::CheckExactChildSize(const armarx::RapidXmlReaderNode& node, const size_t size)
- {
- std::vector<RapidXmlReaderNode> children = node.nodes();
- return children.size() == size;
- }
-
- void Data::EnforceChildSize(const armarx::RapidXmlReaderNode& node, const size_t size)
- {
- if (!Data::CheckExactChildSize(node, size))
- {
- throw error::SizeNotValidException("XMLReaderData", "EnforceChildSize", "The node <" + node.name() + "> has the wrong number of children", node.nodes().size(), size);
- }
- }
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.h b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.h
deleted file mode 100644
index c67f5c1b4845bdc838c33300c92722343f831bba..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <map>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx
-{
- class RapidXmlReaderNode;
-}
-
-namespace armarx::aron::xmltypereader
-{
- class Data
- {
- private:
- Data() = delete;
-
- public:
- // Definition tags
- static constexpr const char* TYPE_DEFINITION_TAG = "arontypedefinition";
-
- static constexpr const char* CODE_INCLUDES_TAG = "codeincludes";
- static constexpr const char* INCLUDES_TAG = "aronincludes";
- static constexpr const char* GENERATE_TYPES_TAG = "generatetypes";
- static constexpr const char* AUTO_CODE_INCLUDE = "autoinclude";
-
- static constexpr const char* INCLUDE_TAG = "include";
- static constexpr const char* GENERATE_OBJECT_TAG = "object";
- static constexpr const char* GENERATE_INT_ENUM_TAG = "intenum";
- static constexpr const char* GENERATE_NDARRAY_TAG = "ndarray";
-
- // Attribute names
- static constexpr const char* METHOD_ATTRIBUTE_NAME = "method";
- static constexpr const char* RETURN_ATTRIBUTE_NAME = "return";
- static constexpr const char* ARGUMENT_TYPE_ATTRIBUTE_NAME = "argumenttype";
- static constexpr const char* INCLUDE_ATTRIBUTE_NAME = "include";
- static constexpr const char* READER_ATTRIBUTE_NAME = "reader";
- static constexpr const char* WRITER_ATTRIBUTE_NAME = "writer";
- static constexpr const char* EXTENDS_ATTRIBUTE_NAME = "extends";
- static constexpr const char* NAME_ATTRIBUTE_NAME = "name";
- static constexpr const char* VALUE_ATTRIBUTE_NAME = "value";
- static constexpr const char* KEY_ATTRIBUTE_NAME = "key";
- static constexpr const char* TYPE_ATTRIBUTE_NAME = "type";
- static constexpr const char* WIDTH_ATTRIBUTE_NAME = "width";
- static constexpr const char* HEIGHT_ATTRIBUTE_NAME = "height";
- static constexpr const char* ROWS_ATTRIBUTE_NAME = "rows";
- static constexpr const char* COLS_ATTRIBUTE_NAME = "cols";
- static constexpr const char* DIMENSIONS_ATTRIBUTE_NAME = "dimensions";
- static constexpr const char* SHAPE_ATTRIBUTE_NAME = "shape";
- static constexpr const char* OPTIONAL_NAME = "optional";
- static constexpr const char* RAW_PTR_NAME = "raw_ptr";
- static constexpr const char* SHARED_PTR_NAME = "shared_ptr";
- static constexpr const char* UNIQUE_PTR_NAME = "unique_ptr";
- static constexpr const char* PACKAGE_NAME = "package";
- static constexpr const char* DOC_BRIEF_NAME = "doc-brief";
- static constexpr const char* DOC_AUTHOR_NAME = "doc-author";
- static constexpr const char* DOC_PARAM_NAME = "doc-param";
-
- // Second level tags. Only important if in specific top level tag
- static constexpr const char* OBJECT_CHILD_TAG = "objectchild";
- static constexpr const char* ENUM_VALUE_TAG = "enumvalue";
-
- // Top Level type tags
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- static constexpr const char* GENERATE_##capsType##_MEMBER_TAG = #lowerType;
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-
- static void EnforceAttribute(const RapidXmlReaderNode& node, const std::string& att);
-
- static bool HasAttribute(const RapidXmlReaderNode& node, const std::string& att);
-
- static std::string GetAttribute(const RapidXmlReaderNode& node, const std::string& att);
-
- static std::string GetAttributeWithDefault(const RapidXmlReaderNode& node, const std::string& att, const std::string def);
-
- static bool AttributeIsTrue(const RapidXmlReaderNode& node, const std::string& att);
-
- static bool HasTagName(const RapidXmlReaderNode& node, const std::string& name);
-
- static void EnforceTagName(const RapidXmlReaderNode& node, const std::string& name);
-
- static std::string GetTagName(const RapidXmlReaderNode& node);
-
- static bool CheckMinChildSize(const RapidXmlReaderNode& node, const size_t size);
-
- static bool CheckMaxChildSize(const RapidXmlReaderNode& node, const size_t size);
-
- static bool CheckExactChildSize(const RapidXmlReaderNode& node, const size_t size);
-
- static void EnforceChildSize(const RapidXmlReaderNode& node, const size_t size);
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.cpp
deleted file mode 100644
index e9795175ad11e15872b4f40594b328e50d5b99b1..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.cpp
+++ /dev/null
@@ -1,479 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// STD/STL
-
-// Simox
-#include <SimoxUtility/algorithm/string.h>
-
-// Header
-#include "ReaderFactory.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.h>
-
-namespace armarx::aron::xmltypereader
-{
- std::stack<codegeneratorhelper::GenerateObjectInfoPtr> ReaderFactory::ObjectGenerationStack = {};
- std::map<std::string, codegeneratorhelper::GenerateObjectInfoPtr> ReaderFactory::AllPublicObjects = {};
- std::map<std::string, codegeneratorhelper::GenerateIntEnumInfoPtr> ReaderFactory::AllPublicIntEnums = {};
-
-
- typenavigator::NavigatorPtr ReaderFactory::create(const RapidXmlReaderNode& node, const Path& path) const
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- {Data::GENERATE_##capsType##_MEMBER_TAG, ReaderFactoryPtr(new upperType##ReaderFactory())},
- static const std::map<std::string, ReaderFactoryPtr> Factories =
- {
- {Data::GENERATE_OBJECT_TAG, ReaderFactoryPtr(new ObjectReaderFactory())},
- {Data::GENERATE_INT_ENUM_TAG, ReaderFactoryPtr(new IntEnumReaderFactory())},
- HANDLE_ALL_ARON_TYPES
- };
-#undef RUN_ARON_MACRO
-
- const std::string tag = simox::alg::to_lower(node.name());
- if (tag == "")
- {
- throw error::AronException("XMLReaderFactory", "create", "An node is empty. Cannot find facory for empty nodes.");
- }
- auto factory_iterator = Factories.find(tag);
- if (factory_iterator != Factories.end())
- {
- return factory_iterator->second->createSpecific(node, path);
- }
-
- // Search for known objects
- return ResolveTypename(tag);
- }
-
- typenavigator::NavigatorPtr ReaderFactory::createSpecific(const RapidXmlReaderNode&, const Path& p) const
- {
- throw error::AronException("ReaderFactory", "createSpecific", "Called disallowed method of an NavigatorFactory. Use child class instead!", p);
- }
-
- typenavigator::NavigatorPtr ReaderFactory::ResolveTypename(const std::string& name)
- {
- const auto public_intenum_it = AllPublicIntEnums.find(name);
- if (public_intenum_it != AllPublicIntEnums.end())
- {
- // copy the navigator
- return typenavigator::Navigator::FromAronType(public_intenum_it->second->correspondingType->toAronTypePtr());
- }
-
- const auto public_obj_it = AllPublicObjects.find(name);
- if (public_obj_it != AllPublicObjects.end())
- {
- // copy the navigator
- return typenavigator::Navigator::FromAronType(public_obj_it->second->correspondingType->toAronTypePtr());
- }
-
- throw error::StringNotValidException("XMLReaderFactory", "ResolveTypename", "Could not find a tag. You can only access already finished public objects.", name);
- }
-
- type::Maybe ReaderFactory::GetMaybe(const RapidXmlReaderNode& n)
- {
- if (Data::AttributeIsTrue(n, Data::OPTIONAL_NAME))
- {
- return type::Maybe::eOptional;
- }
- if (Data::AttributeIsTrue(n, Data::RAW_PTR_NAME))
- {
- return type::Maybe::eRawPointer;
- }
- if (Data::AttributeIsTrue(n, Data::SHARED_PTR_NAME))
- {
- return type::Maybe::eSharedPointer;
- }
- if (Data::AttributeIsTrue(n, Data::UNIQUE_PTR_NAME))
- {
- return type::Maybe::eUniquePointer;
- }
- return type::Maybe::eNone;
- }
-
- // Object type
- typenavigator::NavigatorPtr ObjectReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceAttribute(node, Data::NAME_ATTRIBUTE_NAME);
- const std::string extends = Data::GetAttributeWithDefault(node, Data::EXTENDS_ATTRIBUTE_NAME, "");
- const std::string name = Data::GetAttribute(node, Data::NAME_ATTRIBUTE_NAME);
-
- bool object_is_nested = ObjectGenerationStack.size() > 0;
- if (object_is_nested)
- {
- if (name.rfind("::") != std::string::npos)
- {
- throw error::StringNotValidException("AronObjectTypeXMLReaderFactory", "createSpecific", "Namespaces are not allowed in nested classes", name, path);
- }
- }
-
- // set the new object
- auto aronObjectType = std::make_shared<typenavigator::ObjectNavigator>(path);
- aronObjectType->setObjectName(name);
-
- auto newObject = std::make_shared<codegeneratorhelper::GenerateObjectInfo>();
- newObject->typeName = name;
- newObject->correspondingType = aronObjectType;
- newObject->doc_brief = Data::GetAttributeWithDefault(node, Data::DOC_BRIEF_NAME, "");
- newObject->doc_author = Data::GetAttributeWithDefault(node, Data::DOC_AUTHOR_NAME, "");
-
- if (extends != "")
- {
- auto parentObj = typenavigator::ObjectNavigator::DynamicCastAndCheck(ResolveTypename(simox::alg::to_lower(extends)));
- aronObjectType->setExtends(parentObj);
- }
-
- ObjectGenerationStack.push(newObject);
- for (const RapidXmlReaderNode& objectChild : node.nodes())
- {
- Data::EnforceTagName(objectChild, Data::OBJECT_CHILD_TAG);
- Data::EnforceChildSize(objectChild, 1);
-
- Data::EnforceAttribute(objectChild, Data::KEY_ATTRIBUTE_NAME);
- const std::string key = objectChild.attribute_value(Data::KEY_ATTRIBUTE_NAME);
-
- if (Data::HasAttribute(objectChild, Data::DOC_BRIEF_NAME))
- {
- newObject->doc_members.insert({key, Data::GetAttribute(objectChild, Data::DOC_BRIEF_NAME)});
- }
-
- std::vector<RapidXmlReaderNode> children = objectChild.nodes();
-
- auto maybe = GetMaybe(children[0]);
- typenavigator::NavigatorPtr childNavigator = create(children[0], Path(path, key));
-
- childNavigator->setMaybe(maybe);
- aronObjectType->addMemberType(key, childNavigator);
- }
- ObjectGenerationStack.pop();
-
- if (object_is_nested)
- {
- // We are in a local nested class since there is a parent class in stack
- codegeneratorhelper::GenerateObjectInfoPtr parent = ObjectGenerationStack.top();
- parent->nestedObjects.insert(std::make_pair(simox::alg::to_lower(newObject->typeName), newObject));
- }
- else
- {
- // We are a public top level class. Add to AllPublicObjects
- AllPublicObjects.insert(std::make_pair(simox::alg::to_lower(newObject->typeName), newObject));
- aronObjectType = typenavigator::ObjectNavigator::DynamicCastAndCheck(ResolveTypename(simox::alg::to_lower(newObject->typeName))); // make a copy
- }
-
- ARMARX_CHECK_NOT_NULL(aronObjectType);
- return aronObjectType;
- }
-
- // List type (List)
- typenavigator::NavigatorPtr ListReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_LIST_MEMBER_TAG);
-
- typenavigator::ListNavigatorPtr list(new typenavigator::ListNavigator(path));
- Data::EnforceChildSize(node, 1);
- std::vector<RapidXmlReaderNode> listTypeNodeChildren = node.nodes();
- const RapidXmlReaderNode typeNode = listTypeNodeChildren[0];
- auto maybe = GetMaybe(typeNode);
- typenavigator::NavigatorPtr type = create(typeNode, Path(path, "type"));
- type->setMaybe(maybe);
-
- list->setAcceptedType(type);
- return list;
- }
-
- // List type (Dict)
- typenavigator::NavigatorPtr DictReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_DICT_MEMBER_TAG);
-
- typenavigator::DictNavigatorPtr dict(new typenavigator::DictNavigator(path));
- Data::EnforceChildSize(node, 1);
- std::vector<RapidXmlReaderNode> dictTypeNodeChildren = node.nodes();
- const RapidXmlReaderNode typeNode = dictTypeNodeChildren[0];
- auto maybe = GetMaybe(typeNode);
- typenavigator::NavigatorPtr type = create(typeNode, Path(path, "type"));
- type->setMaybe(maybe);
-
- dict->setAcceptedType(type);
- return dict;
- }
-
- // List type (Tuple)
- typenavigator::NavigatorPtr TupleReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_TUPLE_MEMBER_TAG);
- std::vector<RapidXmlReaderNode> nodeChildren = node.nodes();
-
- if (nodeChildren.size() < 1)
- {
- throw error::AronException("AronTupleTypeXMLReaderFactory", "createSpecific", "A tuple must have at least one type. Found child nodes size: " + std::to_string(nodeChildren.size()));
- }
-
- typenavigator::TupleNavigatorPtr tuple(new typenavigator::TupleNavigator(path));
- unsigned int i = 0;
- for (const RapidXmlReaderNode& tupleTypeDeclarationNode : nodeChildren)
- {
- Data::EnforceChildSize(tupleTypeDeclarationNode, 1);
-
- std::vector<RapidXmlReaderNode> typeNodeChildren = tupleTypeDeclarationNode.nodes();
- const RapidXmlReaderNode typeNode = typeNodeChildren[0];
- auto maybe = GetMaybe(typeNode);
-
- typenavigator::NavigatorPtr type = create(typeNode, Path(path, "<" + std::to_string(i++) + ">"));
- type->setMaybe(maybe);
-
- tuple->addAcceptedType(type);
- }
- return tuple;
- }
-
- // List type (Pair)
- typenavigator::NavigatorPtr PairReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_PAIR_MEMBER_TAG);
- std::vector<RapidXmlReaderNode> nodeChildren = node.nodes();
-
- if (nodeChildren.size() != 2)
- {
- throw error::AronException("AronPairTypeXMLReaderFactory", "createSpecific", "A pair must have two types. Found child nodes size: " + std::to_string(nodeChildren.size()));
- }
-
- typenavigator::PairNavigatorPtr pair(new typenavigator::PairNavigator(path));
-
- Data::EnforceChildSize(nodeChildren[0], 1);
- std::vector<RapidXmlReaderNode> type1NodeChildren = nodeChildren[0].nodes();
- const RapidXmlReaderNode type1Node = type1NodeChildren[0];
-
- auto maybe1 = GetMaybe(type1Node);
-
- typenavigator::NavigatorPtr type1 = create(type1Node, Path(path, std::to_string(0)));
- type1->setMaybe(maybe1);
- pair->setFirstAcceptedType(type1);
-
- Data::EnforceChildSize(nodeChildren[1], 1);
- std::vector<RapidXmlReaderNode> type2NodeChildren = nodeChildren[1].nodes();
- const RapidXmlReaderNode type2Node = type2NodeChildren[0];
-
- auto maybe2 = GetMaybe(type2Node);
-
- typenavigator::NavigatorPtr type2 = create(type2Node, Path(path, std::to_string(1)));
- type2->setMaybe(maybe2);
- pair->setSecondAcceptedType(type2);
-
- return pair;
- }
-
- // Complex type (NDArray)
- typenavigator::NavigatorPtr NDArrayReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- return nullptr;
- }
- // Complex type (EigenMatrix)
- typenavigator::NavigatorPtr EigenMatrixReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_EIGEN_MATRIX_MEMBER_TAG);
- Data::EnforceAttribute(node, Data::TYPE_ATTRIBUTE_NAME);
-
- const int rows = std::stoi(Data::GetAttributeWithDefault(node, Data::ROWS_ATTRIBUTE_NAME, "4"));
- const int cols = std::stoi(Data::GetAttributeWithDefault(node, Data::COLS_ATTRIBUTE_NAME, "4"));
- std::string type = node.attribute_value(Data::TYPE_ATTRIBUTE_NAME);
-
- typenavigator::EigenMatrixNavigatorPtr complex(new typenavigator::EigenMatrixNavigator(path));
- complex->setRows(rows);
- complex->setCols(cols);
- complex->setTypename(type);
- return complex;
- }
-
- // Complex type (EigenQuaternion)
- typenavigator::NavigatorPtr EigenQuaternionReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_EIGEN_QUATERNION_MEMBER_TAG);
- Data::EnforceAttribute(node, Data::TYPE_ATTRIBUTE_NAME);
-
- std::string type = node.attribute_value(Data::TYPE_ATTRIBUTE_NAME);
-
- typenavigator::EigenQuaternionNavigatorPtr complex(new typenavigator::EigenQuaternionNavigator(path));
- complex->setTypename(type);
- return complex;
- }
-
-
- typenavigator::NavigatorPtr ImageReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_IMAGE_MEMBER_TAG);
-
- typenavigator::ImageNavigatorPtr complex = std::make_shared<typenavigator::ImageNavigator>(path);
- complex->setPixelType(node.attribute_value("pixelType"));
-
- return complex;
- }
-
- // Complex type (IVTCByteImage)
- typenavigator::NavigatorPtr IVTCByteImageReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_IVT_CBYTE_IMAGE_MEMBER_TAG);
- typenavigator::IVTCByteImageNavigatorPtr complex(new typenavigator::IVTCByteImageNavigator(path));
- return complex;
- }
-
-
-
- // Complex type (OpenCVMat)
- typenavigator::NavigatorPtr OpenCVMatReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_OPENCV_MAT_MEMBER_TAG);
-
- typenavigator::OpenCVMatNavigatorPtr complex(new typenavigator::OpenCVMatNavigator(path));
-
- std::vector<int> shape;
- {
- std::string shapeStr = node.attribute_value(Data::SHAPE_ATTRIBUTE_NAME);
- const bool trim = true, removeEmpty = false;
- std::vector<std::string> split = simox::alg::split(shapeStr, ",", trim, removeEmpty);
- shape.reserve(split.size());
- for (const std::string& entry : split)
- {
- // What happens if this throws an error?
- int size = std::stoi(entry);
- shape.push_back(size);
- }
- }
- complex->setShape(shape);
-
- std::string typeName = node.attribute_value(Data::TYPE_ATTRIBUTE_NAME);
- complex->setTypeName(typeName);
-
- return complex;
- }
-
- // Complex type (PCLPointCloud)
- typenavigator::NavigatorPtr PCLPointCloudReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_PCL_POINTCLOUD_MEMBER_TAG);
- Data::EnforceAttribute(node, Data::TYPE_ATTRIBUTE_NAME);
- std::string type = node.attribute_value(Data::TYPE_ATTRIBUTE_NAME);
-
- typenavigator::PCLPointCloudNavigatorPtr complex(new typenavigator::PCLPointCloudNavigator(path));
- complex->setTypename(type);
- return complex;
- }
-
- // Complex type (Position)
- typenavigator::NavigatorPtr PositionReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_POSITION_MEMBER_TAG);
-
- typenavigator::PositionNavigatorPtr complex(new typenavigator::PositionNavigator(path));
- return complex;
- }
-
- // Complex type (Orientation)
- typenavigator::NavigatorPtr OrientationReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_ORIENTATION_MEMBER_TAG);
-
- typenavigator::OrientationNavigatorPtr complex(new typenavigator::OrientationNavigator(path));
- return complex;
- }
-
- // Complex type (Pose)
- typenavigator::NavigatorPtr PoseReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceTagName(node, Data::GENERATE_POSE_MEMBER_TAG);
-
- typenavigator::PoseNavigatorPtr complex(new typenavigator::PoseNavigator(path));
- return complex;
- }
-
-
-
- // Enum (IntEnum)
- typenavigator::NavigatorPtr IntEnumReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const
- {
- Data::EnforceAttribute(node, Data::NAME_ATTRIBUTE_NAME);
- const std::string name = Data::GetAttribute(node, Data::NAME_ATTRIBUTE_NAME);
-
- bool enum_is_nested = ObjectGenerationStack.size() > 0;
- if (enum_is_nested)
- {
- if (name.rfind("::") != std::string::npos)
- {
- throw error::StringNotValidException("IntEnumReaderFactory", "createSpecific", "Namespaces are not allowed in nested enums", name, path);
- }
- }
-
- // set the new object
- auto aronIntEnumType = std::make_shared<typenavigator::IntEnumNavigator>(path);
- aronIntEnumType->setEnumName(name);
-
- auto newEnumInfo = std::make_shared<codegeneratorhelper::GenerateIntEnumInfo>();
- newEnumInfo->typeName = name;
- newEnumInfo->correspondingType = aronIntEnumType;
-
- for (const RapidXmlReaderNode& valueChild : node.nodes())
- {
- Data::EnforceTagName(valueChild, Data::ENUM_VALUE_TAG);
- Data::EnforceChildSize(valueChild, 0);
-
- Data::EnforceAttribute(valueChild, Data::KEY_ATTRIBUTE_NAME);
- const std::string key = valueChild.attribute_value(Data::KEY_ATTRIBUTE_NAME);
-
- if (Data::HasAttribute(valueChild, Data::DOC_BRIEF_NAME))
- {
- newEnumInfo->doc_values.insert({key, Data::GetAttribute(valueChild, Data::DOC_BRIEF_NAME)});
- }
-
- Data::EnforceAttribute(valueChild, Data::VALUE_ATTRIBUTE_NAME);
- const std::string value = valueChild.attribute_value(Data::VALUE_ATTRIBUTE_NAME);
-
- aronIntEnumType->addAcceptedValue(key, std::stoi(value));
- }
-
- if (enum_is_nested)
- {
- // We are in a local nested class since there is a parent class in stack
- codegeneratorhelper::GenerateObjectInfoPtr parent = ObjectGenerationStack.top();
- parent->nestedIntEnums.insert(std::make_pair(simox::alg::to_lower(newEnumInfo->typeName), newEnumInfo));
- }
- else
- {
- // We are a public top level class. Add to AllPublicObjects
- AllPublicIntEnums.insert(std::make_pair(simox::alg::to_lower(newEnumInfo->typeName), newEnumInfo));
- }
-
- return aronIntEnumType;
- }
-
- // Primitve Types
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- typenavigator::NavigatorPtr upperType##ReaderFactory::createSpecific(const RapidXmlReaderNode& node, const Path& path) const \
- { \
- Data::EnforceTagName(node, Data::GENERATE_##capsType##_MEMBER_TAG); \
- return typenavigator::NavigatorPtr(new typenavigator::upperType##Navigator(path)); \
- }
-
- HANDLE_PRIMITIVE_TYPES
-#undef RUN_ARON_MACRO
-}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h
deleted file mode 100644
index f94ed41ece1715f61cf0d207064d0e97fe5628b6..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <map>
-#include <vector>
-#include <stack>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/Factory.h>
-
-// ArmarX
-#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/GenerateIntEnumInfo.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-
-namespace armarx::aron::xmltypereader
-{
- class ReaderFactory;
- typedef std::shared_ptr<ReaderFactory> ReaderFactoryPtr;
-
- class ReaderFactory :
- virtual public aron::Factory<RapidXmlReaderNode, typenavigator::NavigatorPtr>
- {
- public:
- ReaderFactory() = default;
-
- virtual typenavigator::NavigatorPtr create(const RapidXmlReaderNode&, const Path&) const override;
- virtual typenavigator::NavigatorPtr createSpecific(const RapidXmlReaderNode&, const Path&) const override;
-
- protected:
- static typenavigator::NavigatorPtr ResolveTypename(const std::string&);
- static type::Maybe GetMaybe(const RapidXmlReaderNode&);
-
- public:
- static std::map<std::string, codegeneratorhelper::GenerateObjectInfoPtr> AllPublicObjects;
- static std::map<std::string, codegeneratorhelper::GenerateIntEnumInfoPtr> AllPublicIntEnums;
-
- protected:
- static std::stack<codegeneratorhelper::GenerateObjectInfoPtr> ObjectGenerationStack;
-
- };
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##ReaderFactory : \
- virtual public ReaderFactory \
- { \
- public: \
- upperType##ReaderFactory() = default; \
- virtual typenavigator::NavigatorPtr createSpecific(const RapidXmlReaderNode&, const Path&) const override; \
- };
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-}
diff --git a/source/RobotAPI/libraries/aron/core/data/converter/Converter.cpp b/source/RobotAPI/libraries/aron/core/data/converter/Converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a359f2b46cd30fe287ba27bd4079beff753080cb
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/converter/Converter.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Converter.h"
+
+namespace armarx::aron::data::converter
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/converter/Converter.h b/source/RobotAPI/libraries/aron/core/data/converter/Converter.h
new file mode 100644
index 0000000000000000000000000000000000000000..611a91f6f05dc20f448ae8221bca0259196e5d96
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/converter/Converter.h
@@ -0,0 +1,132 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "../visitor/Visitor.h"
+#include "../rw/Reader.h"
+#include "../rw/Writer.h"
+
+namespace armarx::aron::data
+{
+ // prototype
+ template <class ConverterImplementation>
+ typename ConverterImplementation::WriterReturnType readAndWrite(typename ConverterImplementation::ReaderInputType& o);
+
+ /// Converter struct providing the needed methods.
+ /// WriterImplementation is a writer class, TODO: add concepts
+ template <class ReaderImplementation, class WriterImplementation, class DerivedT>
+ struct Converter :
+ virtual public Visitor<typename ReaderImplementation::InputType>
+ {
+ using WriterReturnType = typename WriterImplementation::ReturnType;
+ using ReaderInputType = typename ReaderImplementation::InputType;
+ using ReaderInputTypeNonConst = typename ReaderImplementation::InputTypeNonConst;
+
+ ReaderImplementation r;
+ WriterImplementation w;
+ WriterReturnType last_returned;
+
+ virtual ~Converter() = default;
+
+ virtual void visitDict(ReaderInputType& o) override
+ {
+ std::map<std::string, ReaderInputTypeNonConst> elementsOfInput;
+ std::map<std::string, WriterReturnType> elementsReturn;
+ r.readDict(o, elementsOfInput);
+ for (const auto& [key, value] : elementsOfInput)
+ {
+ auto converted = readAndWrite<DerivedT>(value);
+ elementsReturn.insert({key, converted});
+ }
+
+ last_returned = w.writeDict(elementsReturn);
+ };
+ virtual void visitList(ReaderInputType& o) override
+ {
+ std::vector<ReaderInputTypeNonConst> elementsOfInput;
+ std::vector<WriterReturnType> elementsReturn;
+ r.readList(o, elementsOfInput);
+ for (const auto& value : elementsOfInput)
+ {
+ auto converted = readAndWrite<DerivedT>(value);
+ elementsReturn.push_back(converted);
+ }
+ last_returned = w.writeList(elementsReturn);
+ };
+ virtual void visitNDArray(ReaderInputType& o) override
+ {
+ std::string type;
+ std::vector<int> shape;
+ std::vector<unsigned char> data;
+ r.readNDArray(o, shape, type, data);
+ last_returned = w.writeNDArray(shape, type, data.data());
+ };
+ virtual void visitInt(ReaderInputType& o) override
+ {
+ int i;
+ r.readInt(o, i);
+ last_returned = w.writeInt(i);
+ };
+ virtual void visitLong(ReaderInputType& o) override
+ {
+ long i;
+ r.readLong(o, i);
+ last_returned = w.writeLong(i);
+ };
+ virtual void visitFloat(ReaderInputType& o) override
+ {
+ float i;
+ r.readFloat(o, i);
+ last_returned = w.writeFloat(i);
+ };
+ virtual void visitDouble(ReaderInputType& o) override
+ {
+ double i;
+ r.readDouble(o, i);
+ last_returned = w.writeDouble(i);
+ };
+ virtual void visitBool(ReaderInputType& o) override
+ {
+ bool i;
+ r.readBool(o, i);
+ last_returned = w.writeBool(i);
+ };
+ virtual void visitString(ReaderInputType& o) override
+ {
+ std::string i;
+ r.readString(o, i);
+ last_returned = w.writeString(i);
+ };
+ };
+
+ /// the function to read from a variant and write to a writer T
+ /// returns the returntype of T
+ template <class ConverterImplementation>
+ typename ConverterImplementation::WriterReturnType readAndWrite(typename ConverterImplementation::ReaderInputType& o)
+ {
+ ConverterImplementation v;
+ data::visit(v, o);
+ return v.last_returned;
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.cpp b/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6fdd176bee478f6ef1e6fd80e692acd47c9d2fd1
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "NlohmannJSONConverter.h"
+
+namespace armarx::aron::data::converter
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.h b/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..25cd0dc57d26b5dd1bd18c7b39f73e5edcc05f91
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/converter/nlohmannJSON/NlohmannJSONConverter.h
@@ -0,0 +1,50 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include "../Converter.h"
+#include "../../visitor/nlohmannJSON/NlohmannJSONVisitor.h"
+#include "../../rw/reader/nlohmannJSON/NlohmannJSONReader.h"
+
+namespace armarx::aron::data
+{
+ /// Converter struct providing the needed call operators.
+ /// WriterImplementation is a writer class, TODO: add concept
+ template <class WriterImplementation, class DerivedT>
+ struct NlohmannJSONConverter :
+ virtual public ConstNlohmannJSONVisitor,
+ virtual public Converter<aron::data::reader::NlohmannJSONReader, WriterImplementation, DerivedT>
+ {
+ virtual ~NlohmannJSONConverter() = default;
+
+ virtual void visitUnknown(const nlohmann::json& o) override
+ {
+ if (!this->r.readNull(o))
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "A visitor got data but the enum is unknown.");
+ }
+ this->w.writeNull();
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.cpp b/source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4cc04ee1e18fc53dd54a4bf12ed6631ccc83c58
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "VariantConverter.h"
+
+namespace armarx::aron::data::converter
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h b/source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.h
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h
rename to source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.h
index c168b059222c9cbe3811b4c7bf4454647138b89f..4173e7143385e9d7fc1349366f1d38a5aeb3d8c0 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h
+++ b/source/RobotAPI/libraries/aron/core/data/converter/variant/VariantConverter.h
@@ -23,30 +23,29 @@
#pragma once
-// STD/STL
-#include <memory>
-#include <string>
+#include "../Converter.h"
+#include "../../visitor/variant/VariantVisitor.h"
+#include "../../rw/reader/variant/VariantReader.h"
-// ArmarX
-#include <RobotAPI/libraries/aron/core/codegenerator/GenerateIntEnumInfo.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-namespace armarx::aron::codegeneratorhelper
+namespace armarx::aron::data
{
- class GenerateObjectInfo;
- typedef std::shared_ptr<GenerateObjectInfo> GenerateObjectInfoPtr;
-
- class GenerateObjectInfo
+ /// Converter struct providing the needed call operators.
+ /// WriterImplementation is a writer class, TODO: add concept
+ template <class WriterImplementation, class DerivedT>
+ struct VariantConverter :
+ virtual public ConstVariantVisitor,
+ virtual public Converter<aron::data::reader::VariantReader, WriterImplementation, DerivedT>
{
- public:
- std::string typeName;
- std::string definedIn;
- std::string doc_brief;
- std::string doc_author;
- std::map<std::string, std::string> doc_members;
- typenavigator::ObjectNavigatorPtr correspondingType;
+ virtual ~VariantConverter() = default;
- std::map<std::string, GenerateObjectInfoPtr> nestedObjects;
- std::map<std::string, GenerateIntEnumInfoPtr> nestedIntEnums;
+ virtual void visitUnknown(const data::VariantPtr& o) override
+ {
+ if (!this->r.readNull(o))
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "A visitor got data but the enum is unknown.");
+ }
+ this->w.writeNull();
+ }
};
}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/Reader.cpp b/source/RobotAPI/libraries/aron/core/data/rw/Reader.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/io/dataIO/Reader.cpp
rename to source/RobotAPI/libraries/aron/core/data/rw/Reader.cpp
index 2d6a9ff042aeb6e04e75aa8e8fa0de65ab68da38..9889cf16f3f395296092e74c17ddde5e16e99833 100644
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/Reader.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/rw/Reader.cpp
@@ -20,7 +20,7 @@
#include "Reader.h"
-namespace armarx::aron::dataIO
+namespace armarx::aron::data
{
}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/Reader.h b/source/RobotAPI/libraries/aron/core/data/rw/Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..141cba9b8069118f9ec93895d531b03db4920900
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/Reader.h
@@ -0,0 +1,92 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+#include <vector>
+#include <optional>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+namespace armarx::aron::data
+{
+ template <class I>
+ class ReaderInterface
+ {
+ public:
+ using InputType = I;
+ using InputTypeNonConst = typename std::remove_const<InputType>::type;
+
+ virtual ~ReaderInterface() = default;
+
+ virtual void readList(InputType& input, std::vector<InputTypeNonConst>& elements) = 0;
+ virtual void readDict(InputType& input, std::map<std::string, InputTypeNonConst>& elements) = 0;
+
+ virtual void readNDArray(InputType& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data) = 0;
+
+ virtual void readInt(InputType& input, int& i) = 0;
+ virtual void readLong(InputType& input, long& i) = 0;
+ virtual void readFloat(InputType& input, float& i) = 0;
+ virtual void readDouble(InputType& input, double& i) = 0;
+ virtual void readString(InputType& input, std::string& s) = 0;
+ virtual void readBool(InputType& input, bool& i) = 0;
+
+ virtual bool readNull(InputType& input) // defaulted implementation
+ {
+ InputType nil = {};
+ return input == nil;
+ }
+
+ // Convenience methods
+ void readPrimitive(InputType& input, int& i)
+ {
+ return readInt(input, i);
+ }
+
+ void readPrimitive(InputType& input, long& i)
+ {
+ return readLong(input, i);
+ }
+
+ void readPrimitive(InputType& input, float& i)
+ {
+ return readFloat(input, i);
+ }
+
+ void readPrimitive(InputType& input, double& i)
+ {
+ return readDouble(input, i);
+ }
+
+ void readPrimitive(InputType& input, std::string& i)
+ {
+ return readString(input, i);
+ }
+
+ void readPrimitive(InputType& input, bool& i)
+ {
+ return readBool(input, i);
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/Writer.cpp b/source/RobotAPI/libraries/aron/core/data/rw/Writer.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/io/dataIO/Writer.cpp
rename to source/RobotAPI/libraries/aron/core/data/rw/Writer.cpp
index 2a5ff93011457741da3f3dfb89902fb8fa794d26..68a462aac0cea4bdea7c22c456b34d131751462a 100644
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/Writer.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/rw/Writer.cpp
@@ -21,7 +21,7 @@
#include "Writer.h"
-namespace armarx::aron::dataIO
+namespace armarx::aron::data
{
}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/Writer.h b/source/RobotAPI/libraries/aron/core/data/rw/Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7482b13b6ab19f1ca5ef38087e1417a8b1479d56
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/Writer.h
@@ -0,0 +1,89 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+namespace armarx::aron::data
+{
+ template <class R>
+ class WriterInterface
+ {
+ public:
+ using ReturnType = R;
+
+ virtual ~WriterInterface() = default;
+
+ virtual ReturnType writeList(const std::vector<ReturnType>& elements) = 0;
+ virtual ReturnType writeDict(const std::map<std::string, ReturnType>& elements, const std::optional<ReturnType>& extends = std::nullopt) = 0;
+
+ virtual ReturnType writeNDArray(const std::vector<int>& shape, const std::string& typeAsString, const unsigned char* data) = 0;
+
+ virtual ReturnType writeInt(const int i) = 0;
+ virtual ReturnType writeLong(const long i) = 0;
+ virtual ReturnType writeFloat(const float i) = 0;
+ virtual ReturnType writeDouble(const double i) = 0;
+ virtual ReturnType writeString(const std::string& i) = 0;
+ virtual ReturnType writeBool(const bool i) = 0;
+
+ virtual ReturnType writeNull() // defaulted implementation
+ {
+ return {};
+ }
+
+ // Convenience methods
+ ReturnType writePrimitive(const int i)
+ {
+ return writeInt(i);
+ }
+
+ ReturnType writePrimitive(const long i)
+ {
+ return writeLong(i);
+ }
+
+ ReturnType writePrimitive(const float i)
+ {
+ return writeFloat(i);
+ }
+
+ ReturnType writePrimitive(const double i)
+ {
+ return writeDouble(i);
+ }
+
+ ReturnType writePrimitive(const std::string& i)
+ {
+ return writeString(i);
+ }
+
+ ReturnType writePrimitive(const bool i)
+ {
+ return writeBool(i);
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/json/Data.h b/source/RobotAPI/libraries/aron/core/data/rw/json/Data.h
new file mode 100644
index 0000000000000000000000000000000000000000..b26eeff05139b1016db34ff5d452bc4c5cb7852a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/json/Data.h
@@ -0,0 +1,133 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <string>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+namespace armarx::aron::data::rw::json
+{
+ namespace constantes
+ {
+ const std::string TYPE_SLUG = "_ARON_TYPE";
+ const std::string VERSION_SLUG = "_ARON_VERSION";
+
+ const std::string KEY_SLUG = "_ARON_KEY";
+ const std::string VALUE_SLUG = "_ARON_VALUE";
+ const std::string MEMBERS_SLUG = "_ARON_MEMBERS";
+ const std::string ELEMENTS_SLUG = "_ARON_ELEMENTS";
+
+ const std::string NAME_SLUG = "_ARON_NAME";
+ const std::string DIMENSIONS_SLUG = "_ARON_DIMESIONS";
+ const std::string DATA_SLUG = "_ARON_DATA";
+ const std::string USED_TYPE_SLUG = "_ARON_USED_TYPE";
+
+ const std::string LIST_TYPENAME_SLUG = "_ARON_LIST";
+ const std::string DICT_TYPENAME_SLUG = "_ARON_DICT";
+ const std::string NDARRAY_TYPENAME_SLUG = "_ARON_NDARRAY";
+ const std::string INT_TYPENAME_SLUG = "_ARON_INT";
+ const std::string LONG_TYPENAME_SLUG = "_ARON_LONG";
+ const std::string FLOAT_TYPENAME_SLUG = "_ARON_FLOAT";
+ const std::string DOUBLE_TYPENAME_SLUG = "_ARON_DOUBLE";
+ const std::string STRING_TYPENAME_SLUG = "_ARON_STRING";
+ const std::string BOOL_TYPENAME_SLUG = "_ARON_BOOL";
+ const std::string TIME_TYPENAME_SLUG = "_ARON_TIME";
+ }
+
+ namespace conversion
+ {
+ const std::map<data::Descriptor, std::string> Descriptor2String = {
+ {data::Descriptor::eDict, rw::json::constantes::DICT_TYPENAME_SLUG},
+ {data::Descriptor::eList, rw::json::constantes::LIST_TYPENAME_SLUG},
+ {data::Descriptor::eNDArray, rw::json::constantes::NDARRAY_TYPENAME_SLUG},
+ {data::Descriptor::eInt, rw::json::constantes::INT_TYPENAME_SLUG},
+ {data::Descriptor::eLong, rw::json::constantes::LONG_TYPENAME_SLUG},
+ {data::Descriptor::eFloat, rw::json::constantes::FLOAT_TYPENAME_SLUG},
+ {data::Descriptor::eDouble, rw::json::constantes::DOUBLE_TYPENAME_SLUG},
+ {data::Descriptor::eBool, rw::json::constantes::BOOL_TYPENAME_SLUG},
+ {data::Descriptor::eString, rw::json::constantes::STRING_TYPENAME_SLUG}
+ };
+ const auto String2Descriptor = aron::conversion::util::InvertMap(Descriptor2String);
+
+ const std::map<type::Maybe, std::string> Maybe2String =
+ {
+ {type::Maybe::eNone, "type::maybe::none"},
+ {type::Maybe::eOptional, "type::maybe::optional"},
+ {type::Maybe::eRawPointer, "type::maybe::raw_ptr"},
+ {type::Maybe::eSharedPointer, "type::maybe::shared_ptr"},
+ {type::Maybe::eUniquePointer, "type::maybe::unique_ptr"}
+ };
+ const auto String2Maybe = aron::conversion::util::InvertMap(Maybe2String);
+
+ const std::map<type::ndarray::ElementType, std::string> NDArrayType2String =
+ {
+ {type::ndarray::ElementType::int8, "type::ndarray::int8"},
+ {type::ndarray::ElementType::int16, "type::ndarray::int16"},
+ {type::ndarray::ElementType::int32, "type::ndarray::int32"},
+ {type::ndarray::ElementType::uint8, "type::ndarray::uint8"},
+ {type::ndarray::ElementType::uint16, "type::ndarray::uint16"},
+ {type::ndarray::ElementType::uint32, "type::ndarray::uint32"},
+ {type::ndarray::ElementType::float32, "type::ndarray::float32"},
+ {type::ndarray::ElementType::float64, "type::ndarray::float64"}
+ };
+ const auto String2NDArrayType = aron::conversion::util::InvertMap(NDArrayType2String);
+
+ const std::map<type::matrix::ElementType, std::string> MatrixType2String =
+ {
+ {type::matrix::ElementType::int16, "type::matrix::int16"},
+ {type::matrix::ElementType::int32, "type::matrix::int32"},
+ {type::matrix::ElementType::int64, "type::matrix::int64"},
+ {type::matrix::ElementType::float32, "type::matrix::float32"},
+ {type::matrix::ElementType::float64, "type::matrix::float64"}
+ };
+ const auto String2MatrixType = aron::conversion::util::InvertMap(MatrixType2String);
+
+ const std::map<type::quaternion::ElementType, std::string> QuaternionType2String =
+ {
+ {type::quaternion::ElementType::float32, "type::quaternion::float32"},
+ {type::quaternion::ElementType::float64, "type::quaternion::float64"}
+ };
+ const auto String2QuaternionType = aron::conversion::util::InvertMap(QuaternionType2String);
+
+ const std::map<type::image::PixelType, std::string> PixelType2String =
+ {
+ {type::image::PixelType::rgb24, "type::image::rgb24"},
+ {type::image::PixelType::depth32, "type::image::depth32"}
+ };
+ const auto String2PixelType = aron::conversion::util::InvertMap(PixelType2String);
+
+ const std::map<type::pointcloud::VoxelType, std::string> VoxelType2String =
+ {
+ {type::pointcloud::VoxelType::PointXYZ, "type::pointcloud::pointxyz"},
+ {type::pointcloud::VoxelType::PointXYZI, "type::pointcloud::pointxyzi"},
+ {type::pointcloud::VoxelType::PointXYZL, "type::pointcloud::pointxyzl"},
+ {type::pointcloud::VoxelType::PointXYZRGB, "type::pointcloud::pointxyzrgb"},
+ {type::pointcloud::VoxelType::PointXYZRGBA, "type::pointcloud::pointxyzrgba"},
+ {type::pointcloud::VoxelType::PointXYZRGBL, "type::pointcloud::pointxyzrgbl"},
+ {type::pointcloud::VoxelType::PointXYZHSV, "type::pointcloud::pointxyzhsv"}
+ };
+ const auto String2VoxelType = aron::conversion::util::InvertMap(VoxelType2String);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp b/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9719e0e35b1d4a040356eaf309f464ae44a01816
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
@@ -0,0 +1,103 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+#include <memory>
+#include <numeric>
+
+// Header
+#include "NlohmannJSONReader.h"
+
+// ArmarX
+#include "../../json/Data.h"
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+
+
+namespace armarx::aron::data::reader
+{
+ namespace
+ {
+ /// Throw an exception if the type is other than expected
+ void checkInputForCorrectType(const nlohmann::json& input, const std::string& expectedType)
+ {
+ if (input[rw::json::constantes::TYPE_SLUG] != expectedType)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Wrong type in json encountered.", input[rw::json::constantes::TYPE_SLUG], expectedType);
+ }
+ }
+ }
+
+ void NlohmannJSONReader::readList(const nlohmann::json& input, std::vector<nlohmann::json>& elements)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::LIST_TYPENAME_SLUG);
+ elements = input[rw::json::constantes::ELEMENTS_SLUG].get<std::vector<nlohmann::json>>();
+ }
+
+ void NlohmannJSONReader::readDict(const nlohmann::json& input, std::map<std::string, nlohmann::json>& elements)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::DICT_TYPENAME_SLUG);
+ elements = input[rw::json::constantes::ELEMENTS_SLUG].get<std::map<std::string, nlohmann::json>>();
+ }
+
+ void NlohmannJSONReader::readNDArray(const nlohmann::json& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::NDARRAY_TYPENAME_SLUG);
+ shape = input[rw::json::constantes::DIMENSIONS_SLUG].get<std::vector<int>>();
+ typeAsString = input[rw::json::constantes::USED_TYPE_SLUG];
+ data = input[rw::json::constantes::DATA_SLUG].get<std::vector<unsigned char>>();
+ }
+
+ void NlohmannJSONReader::readInt(const nlohmann::json& input, int& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::INT_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+
+ void NlohmannJSONReader::readLong(const nlohmann::json& input, long& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::LONG_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+
+ void NlohmannJSONReader::readFloat(const nlohmann::json& input, float& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::FLOAT_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+
+ void NlohmannJSONReader::readDouble(const nlohmann::json& input, double& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::DOUBLE_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+
+ void NlohmannJSONReader::readString(const nlohmann::json& input, std::string& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::STRING_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+
+ void NlohmannJSONReader::readBool(const nlohmann::json& input, bool& i)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::BOOL_TYPENAME_SLUG);
+ i = input[rw::json::constantes::VALUE_SLUG];
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h b/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..53b1c360b1149237c1497f186750b831210e590b
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h
@@ -0,0 +1,54 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <stack>
+
+// Simox
+#include <SimoxUtility/json.h>
+
+// BaseClass
+#include <RobotAPI/libraries/aron/core/data/rw/Reader.h>
+
+namespace armarx::aron::data::reader
+{
+ class NlohmannJSONReader :
+ virtual public ReaderInterface<const nlohmann::json>
+ {
+ public:
+ // constructors
+ NlohmannJSONReader() = default;
+
+ virtual void readList(const nlohmann::json& input, std::vector<nlohmann::json>& elements) override;
+ virtual void readDict(const nlohmann::json& input, std::map<std::string, nlohmann::json>& elements) override;
+
+ virtual void readNDArray(const nlohmann::json& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data) override;
+
+ virtual void readInt(const nlohmann::json& input, int& i) override;
+ virtual void readLong(const nlohmann::json& input, long& i) override;
+ virtual void readFloat(const nlohmann::json& input, float& i) override;
+ virtual void readDouble(const nlohmann::json& input, double& i) override;
+ virtual void readString(const nlohmann::json& input, std::string& s) override;
+ virtual void readBool(const nlohmann::json& input, bool& i) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.cpp b/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cb1f3cbec377ee2da4564f1cc1030294d1164876
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.cpp
@@ -0,0 +1,91 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+#include <memory>
+#include <numeric>
+
+// Header
+#include "VariantReader.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+
+
+
+namespace armarx::aron::data::reader
+{
+ void VariantReader::readList(const data::VariantPtr& input, std::vector<data::VariantPtr>& elements)
+ {
+ auto o = data::List::DynamicCastAndCheck(input);
+ elements = o->getElements();
+ }
+
+ void VariantReader::readDict(const data::VariantPtr& input, std::map<std::string, data::VariantPtr>& elements)
+ {
+ auto o = data::Dict::DynamicCastAndCheck(input);
+ elements = o->getElements();
+ }
+
+ void VariantReader::readNDArray(const data::VariantPtr& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data)
+ {
+ auto o = data::NDArray::DynamicCastAndCheck(input);
+ shape = o->getShape();
+ typeAsString = o->getType();
+ data = o->getDataAsVector();
+ }
+
+ void VariantReader::readInt(const data::VariantPtr& input, int& i)
+ {
+ auto o = data::Int::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+
+ void VariantReader::readLong(const data::VariantPtr& input, long& i)
+ {
+ auto o = data::Long::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+
+ void VariantReader::readFloat(const data::VariantPtr& input, float& i)
+ {
+ auto o = data::Float::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+
+ void VariantReader::readDouble(const data::VariantPtr& input, double& i)
+ {
+ auto o = data::Double::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+
+ void VariantReader::readString(const data::VariantPtr& input, std::string& i)
+ {
+ auto o = data::String::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+
+ void VariantReader::readBool(const data::VariantPtr& input, bool& i)
+ {
+ auto o = data::Bool::DynamicCastAndCheck(input);
+ i = o->getValue();
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h b/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..33a1a5258e10848aab2fa37a4f71f88a4a57bfb7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h
@@ -0,0 +1,55 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <stack>
+
+// BaseClass
+#include <RobotAPI/libraries/aron/core/data/rw/Reader.h>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
+
+
+namespace armarx::aron::data::reader
+{
+ class VariantReader :
+ virtual public ReaderInterface<const data::VariantPtr>
+ {
+ public:
+ // constructors
+ VariantReader() = default;
+
+ virtual void readList(const data::VariantPtr& input, std::vector<data::VariantPtr>& elements) override;
+ virtual void readDict(const data::VariantPtr& input, std::map<std::string, data::VariantPtr>& elements) override;
+
+ virtual void readNDArray(const data::VariantPtr& input, std::vector<int>& shape, std::string& typeAsString, std::vector<unsigned char>& data) override;
+
+ virtual void readInt(const data::VariantPtr& input, int& i) override;
+ virtual void readLong(const data::VariantPtr& input, long& i) override;
+ virtual void readFloat(const data::VariantPtr& input, float& i) override;
+ virtual void readDouble(const data::VariantPtr& input, double& i) override;
+ virtual void readString(const data::VariantPtr& input, std::string& s) override;
+ virtual void readBool(const data::VariantPtr& input, bool& i) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp b/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a119999ab419398260e7e3a155b768db0a3e2b7
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
@@ -0,0 +1,121 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller (fabian dot peller at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include <numeric>
+
+// Header
+#include "NlohmannJSONWriter.h"
+
+// ArmarX
+#include "../../json/Data.h"
+
+namespace armarx::aron::data::writer
+{
+ namespace
+ {
+ /// Set important members for json object (aron meta information)
+ void setupAronInformationForType(nlohmann::json& json, const std::string& type)
+ {
+ json[rw::json::constantes::TYPE_SLUG] = type;
+ }
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeList(const std::vector<nlohmann::json>& elements)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::LIST_TYPENAME_SLUG);
+ o[rw::json::constantes::ELEMENTS_SLUG] = elements;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeDict(const std::map<std::string, nlohmann::json>& elements, const std::optional<nlohmann::json>& extends)
+ {
+ auto o = extends ? extends.value() : nlohmann::json();
+
+ setupAronInformationForType(o, rw::json::constantes::DICT_TYPENAME_SLUG);
+ o[rw::json::constantes::ELEMENTS_SLUG] = elements;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeNDArray(const std::vector<int>& shape, const std::string& typeAsString, const unsigned char* data)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::NDARRAY_TYPENAME_SLUG);
+ o[rw::json::constantes::DIMENSIONS_SLUG] = shape;
+ o[rw::json::constantes::USED_TYPE_SLUG] = typeAsString;
+
+ int elements = shape.empty() ? 0 : std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<int>());
+ std::vector<unsigned char> d = std::vector<unsigned char>(elements);
+ memcpy(d.data(), data, elements);
+ o[rw::json::constantes::DATA_SLUG] = d;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeInt(const int i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::INT_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeLong(const long i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::LONG_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeFloat(const float i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::FLOAT_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeDouble(const double i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::DOUBLE_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeString(const std::string& i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::STRING_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeBool(const bool i)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::BOOL_TYPENAME_SLUG);
+ o[rw::json::constantes::VALUE_SLUG] = i;
+ return o;
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h b/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..79971333382dacac8fb50a1dd351732fd0044a1d
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
@@ -0,0 +1,54 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD / STL
+#include <memory>
+#include <stack>
+#include <sstream>
+
+// Simox
+#include <SimoxUtility/json.h>
+
+// Base Class
+#include <RobotAPI/libraries/aron/core/data/rw/Writer.h>
+
+namespace armarx::aron::data::writer
+{
+ class NlohmannJSONWriter :
+ virtual public WriterInterface<nlohmann::json>
+ {
+ public:
+ NlohmannJSONWriter() = default;
+
+ nlohmann::json writeList(const std::vector<nlohmann::json>& elements) override;
+ nlohmann::json writeDict(const std::map<std::string, nlohmann::json>& elements, const std::optional<nlohmann::json>& extends = std::nullopt) override;
+
+ nlohmann::json writeNDArray(const std::vector<int>& shape, const std::string& typeAsString, const unsigned char* data) override;
+
+ nlohmann::json writeInt(const int i) override;
+ nlohmann::json writeLong(const long i) override;
+ nlohmann::json writeFloat(const float i) override;
+ nlohmann::json writeDouble(const double i) override;
+ nlohmann::json writeString(const std::string& i) override;
+ nlohmann::json writeBool(const bool i) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.cpp b/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dd2c4d8394d653f42c26857fc0db275d7dd5d3e0
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.cpp
@@ -0,0 +1,107 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+#include <memory>
+#include <numeric>
+
+// Header
+#include "VariantWriter.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+
+
+namespace armarx::aron::data::writer
+{
+
+ data::VariantPtr VariantWriter::writeList(const std::vector<data::VariantPtr>& elements)
+ {
+ auto o = std::make_shared<data::List>();
+ for (const auto& el : elements)
+ {
+ o->addElement(el);
+ }
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeDict(const std::map<std::string, data::VariantPtr>& elements, const std::optional<data::VariantPtr>& extends)
+ {
+ auto o = extends ? data::Dict::DynamicCastAndCheck(extends.value()) : std::make_shared<data::Dict>();
+
+ for(const auto& [key, value] : elements)
+ {
+ o->addElement(key, value);
+ }
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeNDArray(const std::vector<int>& shape, const std::string& typeAsString, const unsigned char* data)
+ {
+ auto o = std::make_shared<data::NDArray>();
+ o->setShape(shape);
+ o->setType(typeAsString);
+ int size = shape.empty() ? 0 : std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<int>());
+ o->setData(static_cast<unsigned int>(size), data);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeInt(const int i)
+ {
+ auto o = std::make_shared<data::Int>();
+ o->setValue(i);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeLong(const long i)
+ {
+ auto o = std::make_shared<data::Long>();
+ o->setValue(i);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeFloat(const float i)
+ {
+ auto o = std::make_shared<data::Float>();
+ o->setValue(i);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeDouble(const double i)
+ {
+ auto o = std::make_shared<data::Double>();
+ o->setValue(i);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeString(const std::string& i)
+ {
+ auto o = std::make_shared<data::String>();
+ o->setValue(i);
+ return o;
+ }
+
+ data::VariantPtr VariantWriter::writeBool(const bool i)
+ {
+ auto o = std::make_shared<data::Bool>();
+ o->setValue(i);
+ return o;
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h b/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..d984ae53cf6f32186744af54c203fb1662e0d808
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h
@@ -0,0 +1,53 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <stack>
+
+// BaseClass
+#include <RobotAPI/libraries/aron/core/data/rw/Writer.h>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
+
+namespace armarx::aron::data::writer
+{
+ class VariantWriter :
+ public WriterInterface<data::VariantPtr>
+ {
+ public:
+ VariantWriter() = default;
+
+ data::VariantPtr writeList(const std::vector<data::VariantPtr>& elements) override;
+ data::VariantPtr writeDict(const std::map<std::string, data::VariantPtr>& elements, const std::optional<data::VariantPtr>& extends = std::nullopt) override;
+
+ data::VariantPtr writeNDArray(const std::vector<int>& shape, const std::string& typeAsString, const unsigned char* data) override;
+
+ data::VariantPtr writeInt(const int i) override;
+ data::VariantPtr writeLong(const long i) override;
+ data::VariantPtr writeFloat(const float i) override;
+ data::VariantPtr writeDouble(const double i) override;
+ data::VariantPtr writeString(const std::string& i) override;
+ data::VariantPtr writeBool(const bool i) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/All.h b/source/RobotAPI/libraries/aron/core/data/variant/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..90d8058061612af5e948a76712108a2974dd7731
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/All.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "container/All.h"
+#include "complex/All.h"
+#include "primitive/All.h"
+
+/**
+ * A convenience header to include all aron files (full include, not forward declared)
+ */
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/Factory.cpp b/source/RobotAPI/libraries/aron/core/data/variant/Factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..94ec4a97f6e8159fa0a68f4a16a83330c55441a9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/Factory.cpp
@@ -0,0 +1,59 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// STD/STL
+
+// Header
+#include "Factory.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+
+namespace armarx::aron::data
+{
+
+ // Access method
+ std::unique_ptr<data::Variant> VariantFactory::create(const data::dto::GenericDataPtr& aron, const Path& path) const
+ {
+ // if aron is null ==> e.g. optional or ptr not set
+ if (!aron)
+ {
+ return nullptr;
+ };
+
+ auto descriptor = data::Aron2Descriptor(*aron);
+ switch(descriptor)
+ {
+ case data::Descriptor::eList: return std::make_unique<data::List>(data::dto::ListPtr::dynamicCast(aron), path);
+ case data::Descriptor::eDict: return std::make_unique<data::Dict>(data::dto::DictPtr::dynamicCast(aron), path);
+ case data::Descriptor::eNDArray: return std::make_unique<data::NDArray>(data::dto::NDArrayPtr::dynamicCast(aron), path);
+ case data::Descriptor::eInt: return std::make_unique<data::Int>(data::dto::AronIntPtr::dynamicCast(aron), path);
+ case data::Descriptor::eLong: return std::make_unique<data::Long>(data::dto::AronLongPtr::dynamicCast(aron), path);
+ case data::Descriptor::eFloat: return std::make_unique<data::Float>(data::dto::AronFloatPtr::dynamicCast(aron), path);
+ case data::Descriptor::eDouble: return std::make_unique<data::Double>(data::dto::AronDoublePtr::dynamicCast(aron), path);
+ case data::Descriptor::eString: return std::make_unique<data::String>(data::dto::AronStringPtr::dynamicCast(aron), path);
+ case data::Descriptor::eBool: return std::make_unique<data::Bool>(data::dto::AronBoolPtr::dynamicCast(aron), path);
+ default: throw error::ValueNotValidException(__PRETTY_FUNCTION__, "", std::to_string((int) descriptor), path);
+ }
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/Factory.h b/source/RobotAPI/libraries/aron/core/data/variant/Factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfb3d09127cee8bfe5297ab9176e993b35878569
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/Factory.h
@@ -0,0 +1,47 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <unordered_map>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/Variant.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+namespace armarx::aron::data
+{
+ /**
+ * @brief The VariantFactory class. Creates a variant from a dto
+ */
+ class VariantFactory
+ {
+ public:
+ VariantFactory() = default;
+ std::unique_ptr<data::Variant> create(const data::dto::GenericDataPtr&, const Path&) const;
+
+ virtual ~VariantFactory() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp b/source/RobotAPI/libraries/aron/core/data/variant/Variant.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/Variant.cpp
index ff4a18c89c6b8cc41c76ce29208006a3eb849e23..ed6b9396cc78aeac9c98e98d28acd932f4d2cf67 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/Variant.cpp
@@ -22,53 +22,49 @@
*/
// Header
-#include "Navigator.h"
+#include "Variant.h"
// ArmarX
#include "../../Exception.h"
-#include "NavigatorFactory.h"
+#include "Factory.h"
#include "container/Dict.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
// static data members
- const NavigatorFactoryPtr Navigator::FACTORY = NavigatorFactoryPtr(new NavigatorFactory());
+ const VariantFactoryPtr Variant::FACTORY = VariantFactoryPtr(new VariantFactory());
// static methods
- NavigatorPtr Navigator::FromAronData(const data::AronDataPtr& a, const Path& path)
+ VariantPtr Variant::FromAronDTO(const data::dto::GenericDataPtr& a, const Path& path)
{
return FACTORY->create(a, path);
}
- std::vector<NavigatorPtr> Navigator::FromAronData(const std::vector<data::AronDataPtr>& a, const Path& path)
+ std::vector<VariantPtr> Variant::FromAronDTO(const std::vector<data::dto::GenericDataPtr>& a, const Path& path)
{
- std::vector<NavigatorPtr> ret;
+ std::vector<VariantPtr> ret;
for (const auto& aron : a)
{
- ret.push_back(Navigator::FromAronData(aron, path));
+ ret.push_back(Variant::FromAronDTO(aron, path));
}
return ret;
}
- std::vector<data::AronDataPtr> Navigator::ToAronData(const std::vector<NavigatorPtr>& a)
+
+ std::vector<data::dto::GenericDataPtr> Variant::ToAronDTO(const std::vector<VariantPtr>& a)
{
- std::vector<data::AronDataPtr> ret;
- for (const auto& aron : a)
+ std::vector<data::dto::GenericDataPtr> ret;
+ for (const auto& v : a)
{
- ret.push_back(aron->toAronPtr());
+ if (v)
+ {
+ ret.push_back(v->toAronDTO());
+ }
+ else
+ {
+ ret.push_back(nullptr);
+ }
}
return ret;
}
-
- NavigatorPtr Navigator::navigateAbsolute(const Path& path) const
- {
- throw error::AronException("Navigator", "navigateAbsolute", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
- }
-
- NavigatorPtr Navigator::navigateRelative(const Path& path) const
- {
- throw error::AronException("Navigator", "navigateRelative", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
- }
-
-
}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/Variant.h b/source/RobotAPI/libraries/aron/core/data/variant/Variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..be3d93336c1f7a3d26c47f7a8d579e4add06d395
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/Variant.h
@@ -0,0 +1,154 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Path.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+
+namespace armarx::aron::data
+{
+ class VariantFactory;
+ typedef std::unique_ptr<VariantFactory> VariantFactoryPtr;
+
+ class Variant;
+ typedef std::shared_ptr<Variant> VariantPtr;
+
+ /**
+ * @brief The Variant class. It represents a data object (a variant containing data).
+ * Every data variant inherits from this class. It provdes basic methods for cast/conversion and
+ * holds a descriptor, specifying the data type.
+ *
+ * If you have a unknown variant and you want to run a specific method based on the type, we suggest to use the visitor pattern (@see data/visitor/Visitor.h)
+ *
+ * Note that a data variant differs from a type variant. A data variant contains data (e.g. if you have a list the data object contains the list elements) while
+ * a type object holds the static type information (e.g. the accepted type of the list).
+ * The elements of a list variant without type information may have different types (e.g. element [0] is an int variant whil element [1] is a string variant)
+ *
+ * Also note, that while a type variant should always be defined (will not be NULL!), a data object can be NULL.
+ * This happens, if a maybe type (e.g. optional) is not set. The underlying ice representation will have a nullptr instead.
+ */
+ class Variant
+ {
+ public:
+ using PointerType = VariantPtr;
+
+ public:
+ // constructors
+ Variant() = delete;
+ Variant(const data::Descriptor& descriptor, const Path& path) :
+ descriptor(descriptor),
+ path(path)
+ {
+ }
+ virtual ~Variant() = default;
+
+ // operators
+ virtual bool operator==(const Variant& other) const = 0;
+ bool operator==(const VariantPtr& other) const
+ {
+ if (!other)
+ {
+ return false;
+ }
+
+ return *this == *other;
+ }
+
+ // static methods
+ /// create a variant from a dto object
+ static VariantPtr FromAronDTO(const data::dto::GenericDataPtr&, const Path& = Path());
+
+ /// create a list of variants from a list of dto objects
+ static std::vector<VariantPtr> FromAronDTO(const std::vector<data::dto::GenericDataPtr>&, const Path& = Path());
+
+ /// return a list of dto objects from a list of variant objects
+ static std::vector<data::dto::GenericDataPtr> ToAronDTO(const std::vector<VariantPtr>&);
+
+ /// getter for the descriptor enum
+ data::Descriptor getDescriptor() const
+ {
+ return descriptor;
+ }
+
+ /// get the path
+ Path getPath() const
+ {
+ return path;
+ }
+
+ /// get the path as string
+ std::string pathToString() const
+ {
+ return path.toString();
+ }
+
+ // virtual definitions
+ /// get a pointer to a copy of this variant
+ virtual VariantPtr clone() const = 0;
+
+ /// get the children of a data variant
+ virtual std::vector<VariantPtr> getChildren() const = 0;
+
+ /// get the children size of a data variant
+ virtual size_t childrenSize() const = 0;
+
+ /// recalculate the type of a data variant. Please not tha the mapping ist NOT bijective, so the calculated type may be wrong
+ virtual type::VariantPtr recalculateType() const = 0;
+
+ /// checks, if the current data variant fullfills the given type
+ virtual bool fullfillsType(const type::VariantPtr&) const = 0;
+
+ /// naviate absoluet (TODO)
+ virtual VariantPtr navigateAbsolute(const Path& path) const = 0;
+
+ /// navigate relative (TODO)
+ virtual VariantPtr navigateRelative(const Path& path) const = 0;
+
+ /// get a short str representation of this variant
+ virtual std::string getShortName() const = 0;
+
+ /// get the full str representation of this variant
+ virtual std::string getFullName() const = 0;
+
+ /// convert the variant to the ice representation
+ virtual data::dto::GenericDataPtr toAronDTO() const = 0;
+
+ protected:
+ const data::Descriptor descriptor;
+ const Path path;
+
+ private:
+ static const VariantFactoryPtr FACTORY;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/complex/All.h b/source/RobotAPI/libraries/aron/core/data/variant/complex/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5aeda85584746114e19fe41be4a2b062ae769ba
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/complex/All.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "NDArray.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.cpp b/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..befc9ea5c3eb07e2f17d380d252c6191e5726ff5
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.cpp
@@ -0,0 +1,209 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "NDArray.h"
+
+// Simox
+#include <SimoxUtility/algorithm/string.h>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/Factory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Position.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.h>
+#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.h>
+
+namespace armarx::aron::data
+{
+ // constructors
+ NDArray::NDArray(const Path& path) :
+ detail::ComplexVariant<data::dto::NDArray, NDArray>::ComplexVariant(data::Descriptor::eNDArray, path)
+ {
+
+ }
+
+ NDArray::NDArray(const data::dto::NDArrayPtr& o, const Path& path) :
+ detail::ComplexVariant<data::dto::NDArray, NDArray>::ComplexVariant(o, data::Descriptor::eNDArray, path)
+ {
+ }
+
+ NDArray::NDArray(const std::vector<int>& dim, const std::string& t, const std::vector<unsigned char>& data, const Path& path) :
+ NDArray(data::dto::NDArrayPtr(new data::dto::NDArray(aron::VERSION, dim, t, data)), path)
+ {
+ }
+
+ // operators
+ bool NDArray::operator==(const NDArray& other) const
+ {
+ const auto otherAron = other.toNDArrayDTO();
+ if (aron->shape != otherAron->shape)
+ {
+ return false;
+ }
+ if (aron->type != otherAron->type)
+ {
+ return false;
+ }
+ // performs memcmp
+ if (aron->data != otherAron->data)
+ {
+ return false;
+ }
+ return true;
+ }
+ bool NDArray::operator==(const NDArrayPtr& other) const
+ {
+ if (!other)
+ {
+ return false;
+ }
+ return *this == *other;
+ }
+
+ // static methods
+ NDArrayPtr NDArray::FromNDArrayDTO(const data::dto::NDArrayPtr& aron)
+ {
+ return std::make_shared<NDArray>(aron);
+ }
+
+ data::dto::NDArrayPtr NDArray::ToNDArrayDTO(const NDArrayPtr& variant)
+ {
+ return variant ? variant->toNDArrayDTO() : nullptr;
+ }
+
+ // public member functions
+ DictPtr NDArray::getAsDict() const
+ {
+ auto dict = std::make_shared<Dict>();
+ auto copy_this = FromAronDTO(toAronDTO(), getPath());
+ dict->addElement("data", copy_this);
+ return dict;
+ }
+
+ unsigned char* NDArray::getData() const
+ {
+ return aron->data.data();
+ }
+
+ void NDArray::setData(unsigned int elements, const unsigned char* src)
+ {
+ aron->data = std::vector<unsigned char>(elements);
+ std::memcpy(aron->data.data(), src, elements);
+ }
+
+ std::vector<unsigned char> NDArray::getDataAsVector() const
+ {
+ return aron->data;
+ }
+
+ std::vector<int> NDArray::getShape() const
+ {
+ return aron->shape;
+ }
+
+ void NDArray::setShape(const std::vector<int>& d)
+ {
+ aron->shape = d;
+ }
+
+ void NDArray::addToShape(int i)
+ {
+ aron->shape.push_back(i);
+ }
+
+ std::string NDArray::getType() const
+ {
+ return aron->type;
+ }
+
+ void NDArray::setType(const std::string& t)
+ {
+ if (t.empty())
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The type cannot be empty", getPath());
+ }
+
+ aron->type = t;
+ }
+
+ data::dto::NDArrayPtr NDArray::toNDArrayDTO() const
+ {
+ return aron;
+ }
+
+ // virtual implementations
+ std::string NDArray::getShortName() const
+ {
+ return "NDArray";
+ }
+
+ std::string NDArray::getFullName() const
+ {
+ return "armarx::aron::data::NDArray<" + simox::alg::to_string(aron->shape, ", ") + ", " + aron->type + ">";
+ }
+
+ type::VariantPtr NDArray::recalculateType() const
+ {
+ // We set all to openCVMat because it accepts n-dimensional types TODO
+ //type::OpenCVMatNavigatorPtr typenav = type::OpenCVMatNavigatorPtr(new type::OpenCVMatNavigator(getPath()));
+ //return typenav;
+ return nullptr;
+ }
+
+ bool NDArray::fullfillsType(const type::VariantPtr& type) const
+ {
+ /*if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
+ {
+ return false;
+ }
+
+ switch (type->getDescriptor())
+ {
+ case type::Descriptor::eMatrix:
+ {
+ auto casted = type::MatrixNavigator::DynamicCast(type);
+ if ((unsigned int) aron->shape[0] != casted->getRows() || (unsigned int) aron->shape[1] != casted->getCols())
+ {
+ return false;
+ }
+ break;
+ }
+ // TODO:
+ default:
+ throw error::AronException("NDArrayNavigator", "fullfillsType", "Could not cast a type to an NDArray-Type", getPath());
+ }*/
+ return true;
+ }
+
+ std::string NDArray::DimensionsToString(const std::vector<int>& dimensions)
+ {
+ std::stringstream ss;
+ ss << "(" << simox::alg::join(simox::alg::multi_to_string(dimensions), ", ") << ")";
+ return ss.str();
+ }
+
+} // namespace armarx::aron::datanavigator
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h b/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h
new file mode 100644
index 0000000000000000000000000000000000000000..31677060acad93fe7fbbbe949b4439d434392931
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h
@@ -0,0 +1,99 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <map>
+#include <numeric>
+#include <vector>
+
+// Base class
+#include "../detail/ComplexVariant.h"
+
+// ArmarX
+#include "../container/Dict.h"
+
+// Types
+#include "../../../type/variant/ndarray/All.h"
+
+
+namespace armarx::aron::data
+{
+ class NDArray;
+ using NDArrayPtr = std::shared_ptr<NDArray>;
+
+ class NDArray :
+ public detail::ComplexVariant<data::dto::NDArray, NDArray>
+ {
+ public:
+ // constructors
+ NDArray(const Path& path = Path());
+ NDArray(const data::dto::NDArrayPtr&, const Path& path = Path());
+ NDArray(const std::vector<int>&, const std::string&, const std::vector<unsigned char>&, const Path& path = Path());
+
+ // operators
+ virtual bool operator==(const NDArray&) const override;
+ bool operator==(const NDArrayPtr&) const override;
+
+ // static methods
+ static PointerType FromNDArrayDTO(const data::dto::NDArrayPtr& aron);
+ static data::dto::NDArrayPtr ToNDArrayDTO(const PointerType& navigator);
+
+ /// Return dimensions in a readable string such as "(2, 3, 4)".
+ static std::string DimensionsToString(const std::vector<int>& dimensions);
+
+ // public member functions
+ DictPtr getAsDict() const;
+
+ unsigned char* getData() const;
+ void setData(unsigned int, const unsigned char*);
+
+ std::vector<unsigned char> getDataAsVector() const;
+
+ std::vector<int> getShape() const;
+ void setShape(const std::vector<int>&);
+ void addToShape(int);
+
+ std::string getType() const;
+ void setType(const std::string&);
+
+ data::dto::NDArrayPtr toNDArrayDTO() const;
+
+ // virtual implementations
+ virtual VariantPtr clone() const override
+ {
+ NDArrayPtr ret(new NDArray(getShape(), getType(), getDataAsVector(), getPath()));
+ return ret;
+ }
+
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/container/All.h b/source/RobotAPI/libraries/aron/core/data/variant/container/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cb13a521a3bcaa19617f3b57a94027b7780229c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/container/All.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "Dict.h"
+#include "List.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/data/variant/container/Dict.cpp
similarity index 63%
rename from source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/container/Dict.cpp
index db8b7a02f37b948c0030cac5090281b10f400aec..62fa05d245337296eabbc1bba0629c050876839c 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/container/Dict.cpp
@@ -25,38 +25,30 @@
#include "Dict.h"
// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Dict.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/data/variant/Factory.h>
#include <SimoxUtility/algorithm/string/string_conversion.h>
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
// constructors
- DictNavigator::DictNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path)
+ Dict::Dict(const Path& path) :
+ detail::ContainerVariant<data::dto::Dict, Dict>::ContainerVariant(data::Descriptor::eDict, path)
{
}
- DictNavigator::DictNavigator(const data::AronDictPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path),
- detail::NavigatorBase<data::AronDict, DictNavigator>(o)
+ Dict::Dict(const data::dto::DictPtr& o, const Path& path) :
+ detail::ContainerVariant<data::dto::Dict, Dict>::ContainerVariant(o, data::Descriptor::eDict, path)
{
for (const auto& [key, dataPtr] : this->aron->elements)
{
- childrenNavigators[key] = Navigator::FromAronData(dataPtr, Path(path, key));
+ childrenNavigators[key] = Variant::FromAronDTO(dataPtr, Path(path, key));
}
}
- DictNavigator::DictNavigator(const data::AronDataDict& d, const Path& path) :
- DictNavigator(data::AronDictPtr(new data::AronDict(d)), path)
- {
- }
-
- DictNavigator::DictNavigator(const std::map<std::string, NavigatorPtr>& m, const Path& path) :
- DictNavigator(path)
+ Dict::Dict(const std::map<std::string, VariantPtr>& m, const Path& path) :
+ Dict(path)
{
for (const auto& [key, dataPtr] : m)
{
@@ -65,7 +57,7 @@ namespace armarx::aron::datanavigator
}
// operators
- bool DictNavigator::operator==(const DictNavigator& other) const
+ bool Dict::operator==(const Dict& other) const
{
for (const auto& [key, nav] : childrenNavigators)
{
@@ -84,7 +76,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool DictNavigator::operator==(const DictNavigatorPtr& other) const
+ bool Dict::operator==(const DictPtr& other) const
{
if (!other)
{
@@ -94,23 +86,23 @@ namespace armarx::aron::datanavigator
}
// static methods
- DictNavigatorPtr DictNavigator::FromAronDictPtr(const data::AronDictPtr& aron)
+ DictPtr Dict::FromAronDictPtr(const data::dto::DictPtr& aron)
{
- return std::make_shared<DictNavigator>(aron);
+ return std::make_shared<Dict>(aron);
}
- data::AronDictPtr DictNavigator::ToAronDictPtr(const DictNavigatorPtr& navigator)
+ data::dto::DictPtr Dict::ToAronDictPtr(const DictPtr& navigator)
{
return navigator ? navigator->toAronDictPtr() : nullptr;
}
- data::AronDictPtr DictNavigator::toAronDictPtr() const
+ data::dto::DictPtr Dict::toAronDictPtr() const
{
return aron;
}
// public member functions
- std::vector<std::string> DictNavigator::getAllKeys() const
+ std::vector<std::string> Dict::getAllKeys() const
{
std::vector<std::string> ret;
for (const auto& [key, _] : childrenNavigators)
@@ -120,31 +112,26 @@ namespace armarx::aron::datanavigator
return ret;
}
- std::string DictNavigator::getAllKeysAsString() const
+ std::string Dict::getAllKeysAsString() const
{
return simox::alg::to_string(getAllKeys(), ", ");
}
- void DictNavigator::addElement(const std::string& key, const NavigatorPtr& data)
+ void Dict::addElement(const std::string& key, const VariantPtr& data)
{
- if (data)
+ if (hasElement(key))
{
- this->childrenNavigators[key] = data;
- this->aron->elements[key] = data->toAronDataPtr();
- }
- else
- {
- this->childrenNavigators[key] = nullptr;
- this->aron->elements[key] = nullptr;
+ throw error::AronException(__PRETTY_FUNCTION__, "The key '"+key+"' already exists in a aron dict.");
}
+ setElement(key, data);
}
- bool DictNavigator::hasElement(const std::string& key) const
+ bool Dict::hasElement(const std::string& key) const
{
return childrenNavigators.count(key) > 0;
}
- NavigatorPtr DictNavigator::getElement(const std::string& key) const
+ VariantPtr Dict::getElement(const std::string& key) const
{
auto it = childrenNavigators.find(key);
if (it == childrenNavigators.end())
@@ -154,32 +141,56 @@ namespace armarx::aron::datanavigator
{
all_keys += child + ", ";
}
- throw error::AronException("DictNavigator", "getElement", "Could not find key '" + key + "'. But I found the following keys: [" + all_keys + "]", getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not find key '" + key + "'. But I found the following keys: [" + all_keys + "]", getPath());
}
return it->second;
}
- std::map<std::string, NavigatorPtr> DictNavigator::getElements() const
+ std::map<std::string, VariantPtr> Dict::getElements() const
{
return childrenNavigators;
}
- void DictNavigator::clear()
+ void Dict::setElement(const std::string& key, const VariantPtr& data)
+ {
+ this->childrenNavigators[key] = data;
+ if (data)
+ {
+ this->aron->elements[key] = data->toAronDTO();
+ }
+ else
+ {
+ this->aron->elements[key] = nullptr;
+ }
+ }
+
+ void Dict::removeElement(const std::string& key)
+ {
+ childrenNavigators.erase(key);
+ aron->elements.erase(key);
+ }
+
+ void Dict::clear()
{
childrenNavigators.clear();
aron->elements.clear();
}
// virtual implementations
- std::string DictNavigator::getName() const
+ std::string Dict::getShortName() const
+ {
+ return "Dict";
+ }
+
+ std::string Dict::getFullName() const
{
- return "AronDict";
+ return "armarx::aron::data::Dict";
}
// TODO
- typenavigator::NavigatorPtr DictNavigator::recalculateType() const
+ type::VariantPtr Dict::recalculateType() const
{
- typenavigator::DictNavigatorPtr typenav = typenavigator::DictNavigatorPtr(new typenavigator::DictNavigator(getPath()));
+ /*type::DictNavigatorPtr typenav = type::DictNavigatorPtr(new type::Dict(getPath()));
for (const auto& [key, nav] : childrenNavigators)
{
if (!nav)
@@ -198,12 +209,13 @@ namespace armarx::aron::datanavigator
throw error::AronException("DictNavigator", "recalculateType", "Cannot recalculate the aronType. Inconsistency found for key: " + key, getPath());
}
}
- return typenav->getAcceptedType();
+ return typenav->getAcceptedType();*/
+ return nullptr;
}
- bool DictNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Dict::fullfillsType(const type::VariantPtr& type) const
{
- if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
+ /*if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
{
return false;
}
@@ -245,12 +257,13 @@ namespace armarx::aron::datanavigator
}
default:
return false;
- }
+ }*/
+ return false;
}
- std::vector<NavigatorPtr> DictNavigator::getChildren() const
+ std::vector<VariantPtr> Dict::getChildren() const
{
- std::vector<NavigatorPtr> ret(childrenNavigators.size());
+ std::vector<VariantPtr> ret(childrenNavigators.size());
for (const auto& [key, nav] : childrenNavigators)
{
ret.push_back(nav);
@@ -258,21 +271,21 @@ namespace armarx::aron::datanavigator
return ret;
}
- size_t DictNavigator::childrenSize() const
+ size_t Dict::childrenSize() const
{
return childrenNavigators.size();
}
- NavigatorPtr DictNavigator::navigateAbsolute(const Path& path) const
+ VariantPtr Dict::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
{
- throw error::AronException("DictNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate without a valid path", path);
}
std::string el = path.getFirstElement();
if (!hasElement(el))
{
- throw error::StringNotValidException("DictNavigator", "navigate", "Could not find an element of a path.", el);
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not find an element of a path.", el, path);
}
if (path.size() == 1)
@@ -284,13 +297,13 @@ namespace armarx::aron::datanavigator
Path next = path.withDetachedFirstElement();
if (!childrenNavigators.at(el))
{
- throw error::AronException("DictNavigator", "navigateAbsolute", "Could not navigate into a NULL member. Seems like the member is optional and not set.", next);
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate into a NULL member. Seems like the member is optional and not set.", next);
}
return childrenNavigators.at(el)->navigateAbsolute(next);
}
}
- NavigatorPtr DictNavigator::navigateRelative(const Path& path) const
+ VariantPtr Dict::navigateRelative(const Path& path) const
{
Path absoluteFromHere = path.getWithoutPrefix(getPath());
return navigateAbsolute(absoluteFromHere);
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/container/Dict.h b/source/RobotAPI/libraries/aron/core/data/variant/container/Dict.h
new file mode 100644
index 0000000000000000000000000000000000000000..01842e78a5ae1c3cec8fc2fac85f2362541a486d
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/container/Dict.h
@@ -0,0 +1,98 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <map>
+
+// Base class
+#include "../detail/ContainerVariant.h"
+
+// ArmarX
+#include "../../../type/variant/container/Dict.h"
+#include "../../../type/variant/container/Object.h"
+
+namespace armarx::aron::data
+{
+ class Dict;
+ typedef std::shared_ptr<Dict> DictPtr;
+
+ class Dict :
+ public detail::ContainerVariant<data::dto::Dict, Dict>
+ {
+ public:
+ // constructors
+ Dict(const Path& path = Path());
+ Dict(const data::dto::DictPtr&, const Path& path = Path());
+ Dict(const std::map<std::string, VariantPtr>&, const Path& path = Path());
+
+ // operators
+ virtual bool operator==(const Dict&) const override;
+ bool operator==(const DictPtr&) const override;
+
+ static PointerType FromAronDictPtr(const data::dto::DictPtr& aron);
+ static data::dto::DictPtr ToAronDictPtr(const PointerType& navigator);
+
+ // public member functions
+ data::dto::DictPtr toAronDictPtr() const;
+ std::vector<std::string> getAllKeys() const;
+ std::string getAllKeysAsString() const;
+
+ void addElement(const std::string& key, const VariantPtr&);
+ bool hasElement(const std::string&) const;
+ void setElement(const std::string&, const VariantPtr&);
+ VariantPtr getElement(const std::string&) const;
+ std::map<std::string, VariantPtr> getElements() const;
+
+ void removeElement(const std::string& key);
+ void clear();
+
+ // virtual implementations
+ virtual VariantPtr clone() const override
+ {
+ DictPtr ret(new Dict(getPath()));
+ for (const auto& [key, val] : getElements())
+ {
+ ret->addElement(key, val->clone());
+ }
+ return ret;
+ }
+
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+ virtual std::vector<VariantPtr> getChildren() const override;
+ virtual size_t childrenSize() const override;
+
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
+
+ virtual VariantPtr navigateAbsolute(const Path& path) const override;
+ virtual VariantPtr navigateRelative(const Path& path) const override;
+
+ private:
+ // members
+ std::map<std::string, VariantPtr> childrenNavigators;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp b/source/RobotAPI/libraries/aron/core/data/variant/container/List.cpp
similarity index 60%
rename from source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/container/List.cpp
index 44f5c61eca8325e2175edbd0245085005dbfdb50..23cc7b8d2cee6067879dd3c6975514445a47eeb3 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/container/List.cpp
@@ -26,37 +26,31 @@
// ArmarX
#include <ArmarXCore/core/exceptions/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/List.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Pair.h>
+#include <RobotAPI/libraries/aron/core/data/variant/Factory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/List.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Tuple.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Pair.h>
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
// constructors
- ListNavigator::ListNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path)
+ List::List(const Path& path) :
+ detail::ContainerVariant<data::dto::List, List>::ContainerVariant(data::Descriptor::eList, path)
{
}
- ListNavigator::ListNavigator(const data::AronListPtr& l, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path),
- detail::NavigatorBase<data::AronList, ListNavigator>(l)
+ List::List(const data::dto::ListPtr& l, const Path& path) :
+ detail::ContainerVariant<data::dto::List, List>::ContainerVariant(l, data::Descriptor::eList, path)
{
unsigned int i = 0;
for (const auto& dataPtr : l->elements)
{
- childrenNavigators.push_back(FromAronData(dataPtr, Path(path, std::to_string(i++))));
+ childrenNavigators.push_back(FromAronDTO(dataPtr, Path(path, std::to_string(i++))));
}
}
- ListNavigator::ListNavigator(const data::AronDataList& d, const Path& path) :
- ListNavigator(data::AronListPtr(new data::AronList(d)), path)
- {
- }
-
- ListNavigator::ListNavigator(const std::vector<NavigatorPtr>& n, const Path& path) :
- ListNavigator(path)
+ List::List(const std::vector<VariantPtr>& n, const Path& path) :
+ List(path)
{
for (const auto& dataPtr : n)
{
@@ -65,7 +59,7 @@ namespace armarx::aron::datanavigator
}
// operators
- bool ListNavigator::operator==(const ListNavigator& other) const
+ bool List::operator==(const List& other) const
{
unsigned int i = 0;
for (const auto& nav : childrenNavigators)
@@ -89,7 +83,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool ListNavigator::operator==(const ListNavigatorPtr& other) const
+ bool List::operator==(const ListPtr& other) const
{
if (!other)
{
@@ -99,79 +93,116 @@ namespace armarx::aron::datanavigator
}
// static methods
- ListNavigatorPtr ListNavigator::FromAronListPtr(const data::AronListPtr& aron)
+ ListPtr List::FromAronListPtr(const data::dto::ListPtr& aron)
{
- return std::make_shared<ListNavigator>(aron);
+ return std::make_shared<List>(aron);
}
- data::AronListPtr ListNavigator::ToAronListPtr(const ListNavigatorPtr& navigator)
+ data::dto::ListPtr List::ToAronListPtr(const ListPtr& navigator)
{
return navigator ? navigator->toAronListPtr() : nullptr;
}
// public member functions
- DictNavigatorPtr ListNavigator::getAsDict() const
+ DictPtr List::getAsDict() const
{
- auto dict = std::make_shared<DictNavigator>();
- auto copy_this = FromAronData(toAronDataPtr(), getPath());
+ auto dict = std::make_shared<Dict>();
+ auto copy_this = FromAronDTO(toAronDTO(), getPath());
dict->addElement("data", copy_this);
return dict;
}
- void ListNavigator::addElement(const NavigatorPtr& n)
+ void List::addElement(const VariantPtr& n)
+ {
+ setElement(aron->elements.size(), n);
+ }
+
+ void List::setElement(unsigned int i, const VariantPtr& n)
{
- if (n)
+ if (i > aron->elements.size())
+ {
+ error::AronException(__PRETTY_FUNCTION__, "Cannot set a listelement at index " + std::to_string(i) + " because this list has size " + std::to_string(aron->elements.size()));
+ }
+
+ if (i == aron->elements.size())
{
childrenNavigators.push_back(n);
- aron->elements.push_back(n->toAronDataPtr());
+ if (n)
+ {
+ aron->elements.push_back(n->toAronDTO());
+ }
+ else
+ {
+ aron->elements.push_back(nullptr);
+ }
}
else
{
- childrenNavigators.push_back(nullptr);
- aron->elements.push_back(nullptr);
+ childrenNavigators[i] = n;
+ if (n)
+ {
+ aron->elements[i] = (n->toAronDTO());
+ }
+ else
+ {
+ aron->elements[i] = nullptr;
+ }
}
}
- bool ListNavigator::hasElement(unsigned int i) const
+ bool List::hasElement(unsigned int i) const
{
return i < childrenNavigators.size();
}
- NavigatorPtr ListNavigator::getElement(unsigned int i) const
+ VariantPtr List::getElement(unsigned int i) const
{
if (i >= childrenNavigators.size())
{
- throw error::AronException("ListNavigator", "getElement", "The index i = " + std::to_string(i) + " is out of bounds (size = " + std::to_string(childrenNavigators.size()) + ")", getPath());
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The index is out of bounds (size = " + std::to_string(childrenNavigators.size()) + ")", std::to_string(i), getPath());
}
return childrenNavigators[i];
}
- std::vector<NavigatorPtr> ListNavigator::getElements() const
+ std::vector<VariantPtr> List::getElements() const
{
return childrenNavigators;
}
- void ListNavigator::clear()
+ void List::removeElement(unsigned int i)
+ {
+ // Use with care since this function will not work in a loop with increasing indexes
+ i = std::min((unsigned int) childrenNavigators.size()-1, i);
+ childrenNavigators.erase(childrenNavigators.begin() + i);
+ aron->elements.erase(aron->elements.begin() + i);
+ }
+
+ void List::clear()
{
childrenNavigators.clear();
aron->elements.clear();
}
- data::AronListPtr ListNavigator::toAronListPtr() const
+ data::dto::ListPtr List::toAronListPtr() const
{
return aron;
}
// virtual implementations
- std::string ListNavigator::getName() const
+ std::string List::getShortName() const
+ {
+ return "List";
+ }
+
+ std::string List::getFullName() const
{
- return "AronList";
+ return "armarx::aron::data::List";
}
// TODO
- typenavigator::NavigatorPtr ListNavigator::recalculateType() const
+ type::VariantPtr List::recalculateType() const
{
- typenavigator::ListNavigatorPtr typenav = typenavigator::ListNavigatorPtr(new typenavigator::ListNavigator(getPath()));
+ /*type::ListNavigatorPtr typenav = type::ListNavigatorPtr(new type::ListNavigator(getPath()));
unsigned int i = 0;
for (const auto& nav : childrenNavigators)
{
@@ -187,12 +218,13 @@ namespace armarx::aron::datanavigator
}
++i;
}
- return typenav->getAcceptedType();
+ return typenav->getAcceptedType();*/
+ return nullptr;
}
- bool ListNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool List::fullfillsType(const type::VariantPtr& type) const
{
- if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
+ /*if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
{
return false;
}
@@ -252,29 +284,30 @@ namespace armarx::aron::datanavigator
}
default:
return false;
- }
+ }*/
+ return false;
}
- std::vector<NavigatorPtr> ListNavigator::getChildren() const
+ std::vector<VariantPtr> List::getChildren() const
{
return childrenNavigators;
}
- size_t ListNavigator::childrenSize() const
+ size_t List::childrenSize() const
{
return childrenNavigators.size();
}
- NavigatorPtr ListNavigator::navigateAbsolute(const Path& path) const
+ VariantPtr List::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
{
- throw error::AronException("ListNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate without a valid path. The path was empty.");
}
unsigned int i = std::stoi(path.getFirstElement());
if (!hasElement(i))
{
- throw error::IndexNotValidException("ListNavigator", "navigate", "Could not find an element of a path.", i, childrenSize());
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not find an element of a path.", std::to_string(i), std::to_string(childrenSize()));
}
if (path.size() == 1)
@@ -286,13 +319,13 @@ namespace armarx::aron::datanavigator
Path next = path.withDetachedFirstElement();
if (!childrenNavigators.at(i))
{
- throw error::AronException("ListNavigator", "navigateAbsolute", "Could not navigate into a NULL member. Seems like the member is optional and not set.", next);
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate into a NULL member. Seems like the member is optional and not set.", next);
}
return childrenNavigators.at(i)->navigateAbsolute(next);
}
}
- NavigatorPtr ListNavigator::navigateRelative(const Path& path) const
+ VariantPtr List::navigateRelative(const Path& path) const
{
Path absoluteFromHere = path.getWithoutPrefix(getPath());
return navigateAbsolute(absoluteFromHere);
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/container/List.h b/source/RobotAPI/libraries/aron/core/data/variant/container/List.h
new file mode 100644
index 0000000000000000000000000000000000000000..d70929e1f75ab8f5fe70c96df35a36da6b077c8c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/container/List.h
@@ -0,0 +1,99 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// Base class
+#include "../detail/SpecializedVariant.h"
+
+// ArmarX
+#include "Dict.h"
+#include "../../../type/variant/container/List.h"
+#include "../../../type/variant/container/Pair.h"
+#include "../../../type/variant/container/Tuple.h"
+
+namespace armarx::aron::data
+{
+ class List;
+ typedef std::shared_ptr<List> ListPtr;
+
+ class List :
+ public detail::ContainerVariant<data::dto::List, List>
+ {
+ public:
+ // constructors
+ List(const Path& path = Path());
+ List(const data::dto::ListPtr&, const Path& path = Path());
+ List(const std::vector<VariantPtr>&, const Path& path = Path());
+
+ // operators
+ virtual bool operator==(const List&) const override;
+ bool operator==(const ListPtr&) const override;
+
+ // static methods
+ static PointerType FromAronListPtr(const data::dto::ListPtr& aron);
+ static data::dto::ListPtr ToAronListPtr(const PointerType& navigator);
+
+ // public member functions
+ DictPtr getAsDict() const;
+
+ data::dto::ListPtr toAronListPtr() const;
+
+ void addElement(const VariantPtr&);
+ void setElement(unsigned int, const VariantPtr&);
+ VariantPtr getElement(unsigned int) const;
+ bool hasElement(unsigned int) const;
+ std::vector<VariantPtr> getElements() const;
+
+ void removeElement(unsigned int);
+
+ void clear();
+
+ // virtual implementations
+ virtual VariantPtr clone() const override
+ {
+ ListPtr ret(new List(getPath()));
+ for (const auto& val : getElements())
+ {
+ ret->addElement(val->clone());
+ }
+ return ret;
+ }
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+ virtual std::vector<VariantPtr> getChildren() const override;
+ virtual size_t childrenSize() const override;
+
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
+
+ virtual VariantPtr navigateAbsolute(const Path& path) const override;
+ virtual VariantPtr navigateRelative(const Path& path) const override;
+
+ private:
+ std::vector<VariantPtr> childrenNavigators;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.cpp
similarity index 97%
rename from source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.cpp
index a5e8c5aa05314a73d33e01c14d01a38976ba88a3..353188045a7fd18ea5bd37fd49c290ccf2ef2f66 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.cpp
@@ -22,4 +22,4 @@
*/
// Header
-#include "NavigatorBase.h"
+#include "ComplexVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.h b/source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.h
new file mode 100644
index 0000000000000000000000000000000000000000..f69e96b35b4a11732e48acceb6fd886573768516
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/ComplexVariant.h
@@ -0,0 +1,64 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+// Base class
+#include "SpecializedVariant.h"
+
+namespace armarx::aron::data::detail
+{
+ template<typename AronDataT, typename DerivedT>
+ class ComplexVariant :
+ public SpecializedVariantBase<AronDataT, DerivedT>
+ {
+ public:
+ using SpecializedVariantBase<AronDataT, DerivedT>::SpecializedVariantBase;
+
+ virtual ~ComplexVariant() = default;
+
+ // virtual implementations
+ virtual std::vector<VariantPtr> getChildren() const override
+ {
+ return {};
+ }
+ virtual size_t childrenSize() const override
+ {
+ return 0;
+ }
+ virtual VariantPtr navigateAbsolute(const Path &path) const override
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate through a non container navigator. The input path was: " + path.toString(), Variant::getPath());
+ }
+
+ virtual VariantPtr navigateRelative(const Path &path) const override
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate through a non container navigator. The input path was: " + path.toString(), Variant::getPath());
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.cpp b/source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.cpp
index 9b592c636489e9b5031c5d54cf3bc517f8f0bdde..edb6ea12df1ba1581419c655971dbb0fc3adb6e0 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/SerializerBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.cpp
@@ -22,4 +22,4 @@
*/
// Header
-#include "SerializerBase.h"
+#include "ContainerVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/Factory.h b/source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.h
similarity index 69%
rename from source/RobotAPI/libraries/aron/core/Factory.h
rename to source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.h
index fe34cd471eba26d6886a3b7ec853c9f52ea76063..69fff7c78e637d961eebad2253327be056f4b7a0 100644
--- a/source/RobotAPI/libraries/aron/core/Factory.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/ContainerVariant.h
@@ -28,21 +28,18 @@
#include <string>
#include <unordered_map>
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/Path.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
+// Base class
+#include "SpecializedVariant.h"
-namespace armarx::aron
+namespace armarx::aron::data::detail
{
- template <typename Input, typename Output>
- class Factory
+ template<typename AronDataT, typename DerivedT>
+ class ContainerVariant :
+ public SpecializedVariantBase<AronDataT, DerivedT>
{
public:
- Factory() = default;
+ using SpecializedVariantBase<AronDataT, DerivedT>::SpecializedVariantBase;
- virtual Output create(const Input&, const Path&) const = 0;
- virtual Output createSpecific(const Input&, const Path&) const = 0;
+ virtual ~ContainerVariant() = default;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.cpp b/source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..578d58c2b1e84647cb68e05c80963943d0fc8f1e
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.cpp
@@ -0,0 +1,26 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveVariant.h"
+
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.h b/source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.h
similarity index 60%
rename from source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.h
index 4e91d3235c4f4234d7a9e3db943571a3dfb438fb..e2c479bbe3679c082b86c8d78391e65c348d9f4b 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/PrimitiveVariant.h
@@ -29,28 +29,31 @@
#include <unordered_map>
// Base class
-#include "NavigatorBase.h"
+#include "SpecializedVariant.h"
// ArmarX
#include "../container/Dict.h"
-namespace armarx::aron::datanavigator::detail
+namespace armarx::aron::data::detail
{
template<typename AronDataT, typename ValueT, typename DerivedT>
- class PrimitiveNavigatorBase :
- virtual public NavigatorBase<AronDataT, DerivedT>
+ class PrimitiveVariant :
+ public SpecializedVariantBase<AronDataT, DerivedT>
{
public:
using ValueType = ValueT;
public:
- PrimitiveNavigatorBase() {}
+ using SpecializedVariantBase<AronDataT, DerivedT>::SpecializedVariantBase;
- PrimitiveNavigatorBase(const ValueT& v)
+ PrimitiveVariant(const ValueT& v, const data::Descriptor descriptor, const Path& path = Path()):
+ SpecializedVariantBase<AronDataT, DerivedT>(descriptor, path)
{
this->aron->value = v;
}
+ virtual ~PrimitiveVariant() = default;
+
operator ValueT() const
{
return this->aron->value;
@@ -69,7 +72,13 @@ namespace armarx::aron::datanavigator::detail
}*/
// virtual implementations
- virtual std::vector<NavigatorPtr> getChildren() const override
+ virtual VariantPtr clone() const override
+ {
+ typename DerivedT::PointerType ret(new DerivedT(getValue(), this->getPath()));
+ return ret;
+ }
+
+ virtual std::vector<VariantPtr> getChildren() const override
{
return {};
}
@@ -77,14 +86,23 @@ namespace armarx::aron::datanavigator::detail
{
return 0;
}
+ virtual VariantPtr navigateAbsolute(const Path &path) const override
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate through a non container navigator. The input path was: " + path.toString(), Variant::getPath());
+ }
+
+ virtual VariantPtr navigateRelative(const Path &path) const override
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not navigate through a non container navigator. The input path was: " + path.toString(), Variant::getPath());
+ }
// static methods
/* public member functions */
- DictNavigatorPtr getAsDict() const
+ DictPtr getAsDict() const
{
- auto dict = std::make_shared<DictNavigator>();
- auto copy_this = FromAronData(this->toAronDataPtr(), this->getPath());
+ auto dict = std::make_shared<Dict>();
+ auto copy_this = FromAronDTO(this->toAronDTO(), this->getPath());
dict->addElement("data", copy_this);
return dict;
}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.cpp b/source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..615d60bbb765c9f9c586abe5ad9f0b0f269a5d70
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "SpecializedVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.h b/source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.h
similarity index 70%
rename from source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.h
index 0c455a3eec808c7b995cb5a611e81139aa7008cc..2507f4d4b33cf0e9919a8ea58e796b32ee4f35a5 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/detail/SpecializedVariant.h
@@ -29,79 +29,77 @@
#include <unordered_map>
// Base class
-#include "../Navigator.h"
+#include "../Variant.h"
// ArmarX
-namespace armarx::aron::datanavigator::detail
+namespace armarx::aron::data::detail
{
template<typename AronDataT, typename DerivedT>
- class NavigatorBase :
- virtual public datanavigator::Navigator
+ class SpecializedVariantBase :
+ public data::Variant
{
public:
using PointerType = std::shared_ptr<DerivedT>;
using AronDataType = AronDataT;
public:
- NavigatorBase() :
+ SpecializedVariantBase() = delete;
+
+ SpecializedVariantBase(const data::Descriptor descriptor, const Path& path = Path()) :
+ Variant(descriptor, path),
aron(new AronDataType())
{
+ aron->VERSION = aron::VERSION;
}
- NavigatorBase(const typename AronDataType::PointerType& o) :
+ SpecializedVariantBase(const typename AronDataType::PointerType& o, const data::Descriptor descriptor, const Path& path = Path()) :
+ Variant(descriptor, path),
aron(o)
{
ARMARX_CHECK_NOT_NULL(aron);
}
+ virtual ~SpecializedVariantBase() = default;
+
// operators
operator typename AronDataType::PointerType()
{
return aron;
}
- virtual bool operator==(const Navigator& other) const override
+ virtual bool operator==(const Variant& other) const override
{
const auto& n = DerivedT::DynamicCast(other);
return *this == n;
}
- virtual bool operator==(const NavigatorPtr& other) const override
- {
- if (!other)
- {
- return false;
- }
- return *this == *other;
- }
virtual bool operator==(const DerivedT&) const = 0;
virtual bool operator==(const PointerType& other) const = 0;
// virtual implementations
- virtual data::AronDataPtr toAronPtr() const override
+ virtual data::dto::GenericDataPtr toAronDTO() const override
{
- ARMARX_CHECK_NOT_NULL(aron);
return aron;
}
// static methods
- static PointerType DynamicCast(const NavigatorPtr& n)
+ static PointerType DynamicCast(const VariantPtr& n)
{
return std::dynamic_pointer_cast<DerivedT>(n);
}
- static DerivedT& DynamicCast(Navigator& n)
+ static DerivedT& DynamicCast(Variant& n)
{
return dynamic_cast<DerivedT&>(n);
}
- static const DerivedT& DynamicCast(const Navigator& n)
+ static const DerivedT& DynamicCast(const Variant& n)
{
return dynamic_cast<const DerivedT&>(n);
}
- static PointerType DynamicCastAndCheck(const NavigatorPtr& n)
+ static PointerType DynamicCastAndCheck(const VariantPtr& n)
{
ARMARX_CHECK_NOT_NULL(n);
auto casted = DerivedT::DynamicCast(n);
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/forward_declarations.h b/source/RobotAPI/libraries/aron/core/data/variant/forward_declarations.h
new file mode 100644
index 0000000000000000000000000000000000000000..45855e03ef9bb364b44da1cc7acd7ec810008a86
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/forward_declarations.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+/**
+ * forward declarations of ALL aron data objects
+ */
+namespace armarx::aron::data
+{
+ class Variant;
+ using VariantPtr = std::shared_ptr<Variant>;
+
+ class Dict;
+ using DictPtr = std::shared_ptr<Dict>;
+
+ class List;
+ using ListPtr = std::shared_ptr<List>;
+
+ class NDArray;
+ using NDArrayPtr = std::shared_ptr<NDArray>;
+
+ class Int;
+ using IntPtr = std::shared_ptr<Int>;
+
+ class Long;
+ using LongPtr = std::shared_ptr<Long>;
+
+ class Float;
+ using FloatPtr = std::shared_ptr<Float>;
+
+ class Double;
+ using DoublePtr = std::shared_ptr<Double>;
+
+ class String;
+ using StringPtr = std::shared_ptr<String>;
+
+ class Bool;
+ using BoolPtr = std::shared_ptr<Bool>;
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/primitive/All.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6fcdf6c4405e8ce348a89195b506aedaa030878
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/All.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Int.h"
+#include "Long.h"
+#include "Float.h"
+#include "Double.h"
+#include "String.h"
+#include "Bool.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.cpp
similarity index 55%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.cpp
index 091343a774a134a760ab9c579aefa2edc6304113..463815cb5a8366136f67ba2e5c3aa11233f49d1a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.cpp
@@ -23,27 +23,26 @@
#include "Bool.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- BoolNavigator::BoolNavigator(const data::AronBoolPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eBool, path),
- detail::NavigatorBase<data::AronBool, BoolNavigator>(o)
+ Bool::Bool(const data::dto::AronBoolPtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronBool, bool, Bool>::PrimitiveVariant(o, data::Descriptor::eBool, path)
{
}
- BoolNavigator::BoolNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eBool, path)
+ Bool::Bool(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronBool, bool, Bool>::PrimitiveVariant(data::Descriptor::eBool, path)
{
}
- BoolNavigator::BoolNavigator(const bool d, const Path& path) :
- BoolNavigator(data::AronBoolPtr(new data::AronBool(d)), path)
+ Bool::Bool(const bool d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronBool, bool, Bool>::PrimitiveVariant(d, data::Descriptor::eBool, path)
{
}
/* operators */
- bool BoolNavigator::operator==(const BoolNavigator& other) const
+ bool Bool::operator==(const Bool& other) const
{
const auto& otherAron = other.toAronBoolPtr();
if (aron->value != otherAron->value)
@@ -52,7 +51,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool BoolNavigator::operator==(const BoolNavigatorPtr& other) const
+ bool Bool::operator==(const BoolPtr& other) const
{
if (!other)
{
@@ -63,35 +62,39 @@ namespace armarx::aron::datanavigator
/* static methods */
- BoolNavigatorPtr BoolNavigator::FromAronBoolPtr(const data::AronBoolPtr& aron)
+ BoolPtr Bool::FromAronBoolPtr(const data::dto::AronBoolPtr& aron)
{
- return std::make_shared<BoolNavigator>(aron);
+ return std::make_shared<Bool>(aron);
}
- data::AronBoolPtr BoolNavigator::ToAronBoolPtr(const BoolNavigatorPtr& navigator)
+ data::dto::AronBoolPtr Bool::ToAronBoolPtr(const BoolPtr& navigator)
{
return navigator ? navigator->toAronBoolPtr() : nullptr;
}
/* public member functions */
- data::AronBoolPtr BoolNavigator::toAronBoolPtr() const
+ data::dto::AronBoolPtr Bool::toAronBoolPtr() const
{
return aron;
}
/* virtual implementations */
- std::string BoolNavigator::getName() const
+ std::string Bool::getShortName() const
{
- return "data::AronBool";
+ return "Bool";
+ }
+ std::string Bool::getFullName() const
+ {
+ return "armarx::aron::data::Bool";
}
- bool BoolNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Bool::fullfillsType(const type::VariantPtr& type) const
{
return type->getDescriptor() == type::Descriptor::eBool;
}
- typenavigator::NavigatorPtr BoolNavigator::recalculateType() const
+ type::VariantPtr Bool::recalculateType() const
{
- return std::make_shared<typenavigator::BoolNavigator>(getPath());
+ return std::make_shared<type::Bool>(getPath());
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.h
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.h
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.h
index b95f1a86e3b84d517807b4b0d25edd7438c6ed12..17a2e016fcdbc8bb61e890f85ae5a29d029c7ecc 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Bool.h
@@ -27,41 +27,42 @@
#include <memory>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
// ArmarX
-#include "../../type/primitive/Bool.h"
+#include "../../../type/variant/primitive/Bool.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
- class BoolNavigator;
- typedef std::shared_ptr<BoolNavigator> BoolNavigatorPtr;
+ class Bool;
+ typedef std::shared_ptr<Bool> BoolPtr;
- class BoolNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronBool, bool, BoolNavigator>
+ class Bool :
+ public detail::PrimitiveVariant<data::dto::AronBool, bool, Bool>
{
public:
/* constructors */
- BoolNavigator(const Path& = Path());
- BoolNavigator(const data::AronBoolPtr&, const Path& = Path());
- BoolNavigator(const bool, const Path& = Path());
+ Bool(const Path& = Path());
+ Bool(const data::dto::AronBoolPtr&, const Path& = Path());
+ Bool(const bool, const Path& = Path());
// operators
- bool operator==(const BoolNavigator& other) const override;
- bool operator==(const BoolNavigatorPtr&) const override;
+ bool operator==(const Bool& other) const override;
+ bool operator==(const BoolPtr&) const override;
// static methods
- static BoolNavigatorPtr FromAronBoolPtr(const data::AronBoolPtr& aron);
- static data::AronBoolPtr ToAronBoolPtr(const BoolNavigatorPtr& navigator);
+ static BoolPtr FromAronBoolPtr(const data::dto::AronBoolPtr& aron);
+ static data::dto::AronBoolPtr ToAronBoolPtr(const BoolPtr& navigator);
// class methods
- data::AronBoolPtr toAronBoolPtr() const;
+ data::dto::AronBoolPtr toAronBoolPtr() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.cpp
similarity index 53%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.cpp
index 352e7abb14aef60126cb82ff7781afd8f427f72c..5fbaaca0a252da5999af4027ad43b9b2301108fc 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.cpp
@@ -27,27 +27,26 @@
// ArmarX
#include "Float.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- DoubleNavigator::DoubleNavigator(const data::AronDoublePtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDouble, path),
- detail::NavigatorBase<data::AronDouble, DoubleNavigator>(o)
+ Double::Double(const data::dto::AronDoublePtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronDouble, double, Double>::PrimitiveVariant(o, data::Descriptor::eDouble, path)
{
}
- DoubleNavigator::DoubleNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDouble, path)
+ Double::Double(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronDouble, double, Double>::PrimitiveVariant(data::Descriptor::eDouble, path)
{
}
- DoubleNavigator::DoubleNavigator(const double d, const Path& path) :
- DoubleNavigator(data::AronDoublePtr(new data::AronDouble(d)), path)
+ Double::Double(const double d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronDouble, double, Double>::PrimitiveVariant(d, data::Descriptor::eDouble, path)
{
}
/* operators */
- bool DoubleNavigator::operator==(const DoubleNavigator& other) const
+ bool Double::operator==(const Double& other) const
{
const auto& otherAron = other.toAronDoublePtr();
if (this->aron->value != otherAron->value)
@@ -56,7 +55,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool DoubleNavigator::operator==(const DoubleNavigatorPtr& other) const
+ bool Double::operator==(const DoublePtr& other) const
{
if (!other)
{
@@ -66,37 +65,43 @@ namespace armarx::aron::datanavigator
}
/* static methods */
- DoubleNavigatorPtr DoubleNavigator::FromAronDoublePtr(const data::AronDoublePtr& aron)
+ DoublePtr Double::FromAronDoublePtr(const data::dto::AronDoublePtr& aron)
{
- return std::make_shared<DoubleNavigator>(aron);
+ return std::make_shared<Double>(aron);
}
- data::AronDoublePtr DoubleNavigator::ToAronDoublePtr(const DoubleNavigatorPtr& navigator)
+ data::dto::AronDoublePtr Double::ToAronDoublePtr(const DoublePtr& navigator)
{
return navigator ? navigator->toAronDoublePtr() : nullptr;
}
/* public member functions */
- data::AronDoublePtr DoubleNavigator::toAronDoublePtr() const
+ data::dto::AronDoublePtr Double::toAronDoublePtr() const
{
return aron;
}
/* virtual implementations */
- std::string DoubleNavigator::getName() const
+ std::string Double::getShortName() const
{
- return "data::AronDouble";
+ return "Double";
+ }
+ std::string Double::getFullName() const
+ {
+ return "armarx::aron::data::Double";
}
- bool DoubleNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Double::fullfillsType(const type::VariantPtr& type) const
{
- const auto f = FloatNavigator();
- return type->getDescriptor() == type::Descriptor::eDouble || f.fullfillsType(type);
+ /*const auto f = FloatNavigator();
+ return type->getDescriptor() == type::Descriptor::eDouble || f.fullfillsType(type);*/
+ return false;
}
- typenavigator::NavigatorPtr DoubleNavigator::recalculateType() const
+ type::VariantPtr Double::recalculateType() const
{
- return std::make_shared<typenavigator::DoubleNavigator>(getPath());
+ //return std::make_shared<typenavigator::DoubleNavigator>(getPath());
+ return nullptr;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.h
similarity index 53%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.h
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.h
index f9593ec4059b9676dd56df76196418c82465f17c..cf02c8e4ef5e50d8e78697e553c271d09cc51a6a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Double.h
@@ -27,41 +27,42 @@
#include <memory>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
// ArmarX
-#include "../../type/primitive/Long.h"
+#include "../../../type/variant/primitive/Double.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
- class LongNavigator;
- typedef std::shared_ptr<LongNavigator> LongNavigatorPtr;
+ class Double;
+ typedef std::shared_ptr<Double> DoublePtr;
- class LongNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronLong, long, LongNavigator>
+ class Double :
+ public detail::PrimitiveVariant<data::dto::AronDouble, double, Double>
{
public:
/* constructors */
- LongNavigator(const Path& = Path());
- LongNavigator(const data::AronLongPtr&, const Path& = Path());
- LongNavigator(const long, const Path& = Path());
+ Double(const Path& = Path());
+ Double(const data::dto::AronDoublePtr&, const Path& = Path());
+ Double(const double, const Path& = Path());
/* operators */
- bool operator==(const LongNavigator&) const override;
- bool operator==(const LongNavigatorPtr&) const override;
+ bool operator==(const Double&) const override;
+ bool operator==(const DoublePtr&) const override;
/* static methods */
- static LongNavigatorPtr FromAronLongPtr(const data::AronLongPtr& aron);
- static data::AronLongPtr ToAronLongPtr(const LongNavigatorPtr& navigator);
+ static DoublePtr FromAronDoublePtr(const data::dto::AronDoublePtr& aron);
+ static data::dto::AronDoublePtr ToAronDoublePtr(const DoublePtr& navigator);
/* public member functions */
- data::AronLongPtr toAronLongPtr() const;
+ data::dto::AronDoublePtr toAronDoublePtr() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.cpp
similarity index 53%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.cpp
index 145e96f9d2baa2292354556eac3fc67a2c54a192..b00a40215bba8f865ff36d5651452bbf963b4954 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.cpp
@@ -23,27 +23,26 @@
#include "Float.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- FloatNavigator::FloatNavigator(const data::AronFloatPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eFloat, path),
- detail::NavigatorBase<data::AronFloat, FloatNavigator>(o)
+ Float::Float(const data::dto::AronFloatPtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronFloat, float, Float>::PrimitiveVariant(o, data::Descriptor::eFloat, path)
{
}
- FloatNavigator::FloatNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eFloat, path)
+ Float::Float(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronFloat, float, Float>::PrimitiveVariant(data::Descriptor::eFloat, path)
{
}
- FloatNavigator::FloatNavigator(const float d, const Path& path) :
- FloatNavigator(data::AronFloatPtr(new data::AronFloat(d)), path)
+ Float::Float(const float d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronFloat, float, Float>::PrimitiveVariant(d, data::Descriptor::eFloat, path)
{
}
/* operators */
- bool FloatNavigator::operator==(const FloatNavigator& other) const
+ bool Float::operator==(const Float& other) const
{
const auto& otherAron = other.toAronFloatPtr();
if (this->aron->value != otherAron->value)
@@ -52,7 +51,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool FloatNavigator::operator==(const FloatNavigatorPtr& other) const
+ bool Float::operator==(const FloatPtr& other) const
{
if (!other)
{
@@ -63,36 +62,42 @@ namespace armarx::aron::datanavigator
/* static methods */
- FloatNavigatorPtr FloatNavigator::FromAronFloatPtr(const data::AronFloatPtr& aron)
+ FloatPtr Float::FromAronFloatPtr(const data::dto::AronFloatPtr& aron)
{
- return std::make_shared<FloatNavigator>(aron);
+ return std::make_shared<Float>(aron);
}
- data::AronFloatPtr FloatNavigator::ToAronFloatPtr(const FloatNavigatorPtr& navigator)
+ data::dto::AronFloatPtr Float::ToAronFloatPtr(const FloatPtr& navigator)
{
return navigator ? navigator->toAronFloatPtr() : nullptr;
}
/* public member functions */
- data::AronFloatPtr FloatNavigator::toAronFloatPtr() const
+ data::dto::AronFloatPtr Float::toAronFloatPtr() const
{
return aron;
}
/* virtual implementations */
- std::string FloatNavigator::getName() const
+ std::string Float::getShortName() const
{
- return "data::AronFloat";
+ return "Float";
+ }
+ std::string Float::getFullName() const
+ {
+ return "armarx::aron::data::Float";
}
- bool FloatNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Float::fullfillsType(const type::VariantPtr& type) const
{
- return type->getDescriptor() == type::Descriptor::eFloat;
+ //return type->getDescriptor() == type::Descriptor::eFloat;
+ return false;
}
- typenavigator::NavigatorPtr FloatNavigator::recalculateType() const
+ type::VariantPtr Float::recalculateType() const
{
- return std::make_shared<typenavigator::FloatNavigator>(getPath());
+ //return std::make_shared<typenavigator::FloatNavigator>(getPath());
+ return nullptr;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.h
similarity index 53%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.h
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.h
index 317650e847695cde2700867757c0407b1fc7d8a0..925fdcae00351b5b916d72ca91db7fc1ebca22eb 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Float.h
@@ -27,41 +27,42 @@
#include <memory>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
// ArmarX
-#include "../../type/primitive/Int.h"
+#include "../../../type/variant/primitive/Float.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
- class IntNavigator;
- typedef std::shared_ptr<IntNavigator> IntNavigatorPtr;
+ class Float;
+ typedef std::shared_ptr<Float> FloatPtr;
- class IntNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronInt, int, IntNavigator>
+ class Float :
+ public detail::PrimitiveVariant<data::dto::AronFloat, float, Float>
{
public:
/* constructors */
- IntNavigator(const Path& = Path());
- IntNavigator(const data::AronIntPtr&, const Path& = Path());
- IntNavigator(const int, const Path& = Path());
+ Float(const Path& = Path());
+ Float(const data::dto::AronFloatPtr&, const Path& = Path());
+ Float(const float, const Path& = Path());
/* operators */
- bool operator==(const IntNavigator&) const override;
- bool operator==(const IntNavigatorPtr&) const override;
+ bool operator==(const Float&) const override;
+ bool operator==(const FloatPtr&) const override;
/* static methods */
- static IntNavigatorPtr FromAronIntPtr(const data::AronIntPtr& aron);
- static data::AronIntPtr ToAronIntPtr(const IntNavigatorPtr& navigator);
+ static FloatPtr FromAronFloatPtr(const data::dto::AronFloatPtr& aron);
+ static data::dto::AronFloatPtr ToAronFloatPtr(const FloatPtr& navigator);
/* public member functions */
- data::AronIntPtr toAronIntPtr() const;
+ data::dto::AronFloatPtr toAronFloatPtr() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.cpp
index 29c706c12774e2aef91d962a66260db4dc5d7d21..da8ce3f4da647e29379848ba7bd3eb8975689c74 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Int.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.cpp
@@ -23,30 +23,29 @@
#include "Int.h"
-#include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/primitive/Int.h>
+#include <RobotAPI/libraries/aron/core/data/variant/Factory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/primitive/Int.h>
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- IntNavigator::IntNavigator(const data::AronIntPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eInt, path),
- detail::NavigatorBase<data::AronInt, IntNavigator>(o)
+ Int::Int(const data::dto::AronIntPtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronInt, int, Int>::PrimitiveVariant(o, data::Descriptor::eInt, path)
{
}
- IntNavigator::IntNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eInt, path)
+ Int::Int(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronInt, int, Int>::PrimitiveVariant(data::Descriptor::eInt, path)
{
}
- IntNavigator::IntNavigator(const int d, const Path& path) :
- IntNavigator(data::AronIntPtr(new data::AronInt(d)), path)
+ Int::Int(const int d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronInt, int, Int>::PrimitiveVariant(d, data::Descriptor::eInt, path)
{
}
/* operators */
- bool IntNavigator::operator==(const IntNavigator& other) const
+ bool Int::operator==(const Int& other) const
{
const auto& otherAron = other.toAronIntPtr();
if (this->aron->value != otherAron->value)
@@ -55,7 +54,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool IntNavigator::operator==(const IntNavigatorPtr& other) const
+ bool Int::operator==(const IntPtr& other) const
{
if (!other)
{
@@ -66,36 +65,42 @@ namespace armarx::aron::datanavigator
/* static methods */
- IntNavigatorPtr IntNavigator::FromAronIntPtr(const data::AronIntPtr& aron)
+ IntPtr Int::FromAronIntPtr(const data::dto::AronIntPtr& aron)
{
- return std::make_shared<IntNavigator>(aron);
+ return std::make_shared<Int>(aron);
}
- data::AronIntPtr IntNavigator::ToAronIntPtr(const IntNavigatorPtr& navigator)
+ data::dto::AronIntPtr Int::ToAronIntPtr(const IntPtr& navigator)
{
return navigator ? navigator->toAronIntPtr() : nullptr;
}
/* public member functions */
- data::AronIntPtr IntNavigator::toAronIntPtr() const
+ data::dto::AronIntPtr Int::toAronIntPtr() const
{
return aron;
}
/* virtual implementations */
- std::string IntNavigator::getName() const
+ std::string Int::getShortName() const
{
- return "data::AronInt";
+ return "Int";
+ }
+ std::string Int::getFullName() const
+ {
+ return "armarx::aron::data::Int";
}
- bool IntNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Int::fullfillsType(const type::VariantPtr& type) const
{
- return type->getDescriptor() == type::Descriptor::eInt || type->getDescriptor() == type::Descriptor::eIntEnum;
+ //return type->getDescriptor() == type::Descriptor::eInt || type->getDescriptor() == type::Descriptor::eIntEnum;
+ return false;
}
- typenavigator::NavigatorPtr IntNavigator::recalculateType() const
+ type::VariantPtr Int::recalculateType() const
{
- return std::make_shared<typenavigator::IntNavigator>(getPath());
+ //return std::make_shared<typenavigator::IntNavigator>(getPath());
+ return nullptr;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.h
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.h
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.h
index b060f82d9606c14baf63c539450fc2beed1a6a89..2ccb032e64eb518442468625b7013adddfdbe9d2 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Int.h
@@ -27,41 +27,42 @@
#include <memory>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
// ArmarX
-#include "../../type/primitive/Float.h"
+#include "../../../type/variant/primitive/Int.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
- class FloatNavigator;
- typedef std::shared_ptr<FloatNavigator> FloatNavigatorPtr;
+ class Int;
+ typedef std::shared_ptr<Int> IntPtr;
- class FloatNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronFloat, float, FloatNavigator>
+ class Int :
+ public detail::PrimitiveVariant<data::dto::AronInt, int, Int>
{
public:
/* constructors */
- FloatNavigator(const Path& = Path());
- FloatNavigator(const data::AronFloatPtr&, const Path& = Path());
- FloatNavigator(const float, const Path& = Path());
+ Int(const Path& = Path());
+ Int(const data::dto::AronIntPtr&, const Path& = Path());
+ Int(const int, const Path& = Path());
/* operators */
- bool operator==(const FloatNavigator&) const override;
- bool operator==(const FloatNavigatorPtr&) const override;
+ bool operator==(const Int&) const override;
+ bool operator==(const IntPtr&) const override;
/* static methods */
- static FloatNavigatorPtr FromAronFloatPtr(const data::AronFloatPtr& aron);
- static data::AronFloatPtr ToAronFloatPtr(const FloatNavigatorPtr& navigator);
+ static IntPtr FromAronIntPtr(const data::dto::AronIntPtr& aron);
+ static data::dto::AronIntPtr ToAronIntPtr(const IntPtr& navigator);
/* public member functions */
- data::AronFloatPtr toAronFloatPtr() const;
+ data::dto::AronIntPtr toAronIntPtr() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.cpp
similarity index 56%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.cpp
index 73676a1d51c21f9f7f37b2d3b92eaf429f20afe2..38503db1b5bf414abdcc6dff2c9c252a52c7eaa0 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Long.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.cpp
@@ -27,27 +27,26 @@
// ArmarX
#include "Int.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- LongNavigator::LongNavigator(const data::AronLongPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eLong, path),
- detail::NavigatorBase<data::AronLong, LongNavigator>(o)
+ Long::Long(const data::dto::AronLongPtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronLong, long, Long>::PrimitiveVariant(o, data::Descriptor::eLong, path)
{
}
- LongNavigator::LongNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eLong, path)
+ Long::Long(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronLong, long, Long>::PrimitiveVariant(data::Descriptor::eLong, path)
{
}
- LongNavigator::LongNavigator(const long d, const Path& path) :
- LongNavigator(data::AronLongPtr(new data::AronLong(d)), path)
+ Long::Long(const long d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronLong, long, Long>::PrimitiveVariant(d, data::Descriptor::eLong, path)
{
}
/* operators */
- bool LongNavigator::operator==(const LongNavigator& other) const
+ bool Long::operator==(const Long& other) const
{
const auto& otherAron = other.toAronLongPtr();
if (this->aron->value != otherAron->value)
@@ -56,7 +55,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool LongNavigator::operator==(const LongNavigatorPtr& other) const
+ bool Long::operator==(const LongPtr& other) const
{
if (!other)
{
@@ -67,37 +66,43 @@ namespace armarx::aron::datanavigator
/* static methods */
- LongNavigatorPtr LongNavigator::FromAronLongPtr(const data::AronLongPtr& aron)
+ LongPtr Long::FromAronLongPtr(const data::dto::AronLongPtr& aron)
{
- return std::make_shared<LongNavigator>(aron);
+ return std::make_shared<Long>(aron);
}
- data::AronLongPtr LongNavigator::ToAronLongPtr(const LongNavigatorPtr& navigator)
+ data::dto::AronLongPtr Long::ToAronLongPtr(const LongPtr& navigator)
{
return navigator ? navigator->toAronLongPtr() : nullptr;
}
/* public member functions */
- data::AronLongPtr LongNavigator::toAronLongPtr() const
+ data::dto::AronLongPtr Long::toAronLongPtr() const
{
return aron;
}
/* virtual implementations */
- std::string LongNavigator::getName() const
+ std::string Long::getShortName() const
{
- return "data::AronLong";
+ return "Long";
+ }
+ std::string Long::getFullName() const
+ {
+ return "armarx::aron::data::Long";
}
- bool LongNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool Long::fullfillsType(const type::VariantPtr& type) const
{
- const auto i = IntNavigator();
- return type->getDescriptor() == type::Descriptor::eLong || type->getDescriptor() == type::Descriptor::eTime || i.fullfillsType(type);
+ /*const auto i = IntNavigator();
+ return type->getDescriptor() == type::Descriptor::eLong || type->getDescriptor() == type::Descriptor::eTime || i.fullfillsType(type); */
+ return false;
}
- typenavigator::NavigatorPtr LongNavigator::recalculateType() const
+ type::VariantPtr Long::recalculateType() const
{
- return std::make_shared<typenavigator::LongNavigator>(getPath());
+ //return std::make_shared<typenavigator::LongNavigator>(getPath());
+ return nullptr;
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.h
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.h
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.h
index 4996bc46bd479fe4318c9bb6bcf8228c453c65fc..d14335b6267f4ee07d39be65dfa03d5645369f2f 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.h
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/Long.h
@@ -27,41 +27,43 @@
#include <memory>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
// ArmarX
-#include "../../type/primitive/Double.h"
+#include "../../../type/variant/primitive/Long.h"
+#include "../../../type/variant/primitive/Time.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
- class DoubleNavigator;
- typedef std::shared_ptr<DoubleNavigator> DoubleNavigatorPtr;
+ class Long;
+ typedef std::shared_ptr<Long> LongPtr;
- class DoubleNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronDouble, double, DoubleNavigator>
+ class Long :
+ public detail::PrimitiveVariant<data::dto::AronLong, long, Long>
{
public:
/* constructors */
- DoubleNavigator(const Path& = Path());
- DoubleNavigator(const data::AronDoublePtr&, const Path& = Path());
- DoubleNavigator(const double, const Path& = Path());
+ Long(const Path& = Path());
+ Long(const data::dto::AronLongPtr&, const Path& = Path());
+ Long(const long, const Path& = Path());
/* operators */
- bool operator==(const DoubleNavigator&) const override;
- bool operator==(const DoubleNavigatorPtr&) const override;
+ bool operator==(const Long&) const override;
+ bool operator==(const LongPtr&) const override;
/* static methods */
- static DoubleNavigatorPtr FromAronDoublePtr(const data::AronDoublePtr& aron);
- static data::AronDoublePtr ToAronDoublePtr(const DoubleNavigatorPtr& navigator);
+ static LongPtr FromAronLongPtr(const data::dto::AronLongPtr& aron);
+ static data::dto::AronLongPtr ToAronLongPtr(const LongPtr& navigator);
/* public member functions */
- data::AronDoublePtr toAronDoublePtr() const;
+ data::dto::AronLongPtr toAronLongPtr() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.cpp b/source/RobotAPI/libraries/aron/core/data/variant/primitive/String.cpp
similarity index 54%
rename from source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.cpp
rename to source/RobotAPI/libraries/aron/core/data/variant/primitive/String.cpp
index 11477863e1062e53575bfa5482f5e767a57ad2c6..878a75f306804a6b3a5dcc25935f46c1ddd014cc 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/String.cpp
@@ -23,27 +23,26 @@
#include "String.h"
-namespace armarx::aron::datanavigator
+namespace armarx::aron::data
{
/* constructors */
- StringNavigator::StringNavigator(const data::AronStringPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eString, path),
- detail::NavigatorBase<data::AronString, StringNavigator>(o)
+ String::String(const data::dto::AronStringPtr& o, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronString, std::string, String>::PrimitiveVariant(o, data::Descriptor::eString, path)
{
}
- StringNavigator::StringNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eString, path)
+ String::String(const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronString, std::string, String>::PrimitiveVariant(data::Descriptor::eString, path)
{
}
- StringNavigator::StringNavigator(const std::string& d, const Path& path) :
- StringNavigator(data::AronStringPtr(new data::AronString(d)), path)
+ String::String(const std::string& d, const Path& path) :
+ detail::PrimitiveVariant<data::dto::AronString, std::string, String>::PrimitiveVariant(d, data::Descriptor::eString, path)
{
}
/* operators */
- bool StringNavigator::operator==(const StringNavigator& other) const
+ bool String::operator==(const String& other) const
{
const auto& otherAron = other.toAronStringPtr();
if (this->aron->value != otherAron->value)
@@ -52,7 +51,7 @@ namespace armarx::aron::datanavigator
}
return true;
}
- bool StringNavigator::operator==(const StringNavigatorPtr& other) const
+ bool String::operator==(const StringPtr& other) const
{
if (!other)
{
@@ -63,36 +62,40 @@ namespace armarx::aron::datanavigator
/* static methods */
- StringNavigatorPtr StringNavigator::FromAronStringPtr(const data::AronStringPtr& aron)
+ StringPtr String::FromAronStringPtr(const data::dto::AronStringPtr& aron)
{
- return std::make_shared<StringNavigator>(aron);
+ return std::make_shared<String>(aron);
}
- data::AronStringPtr StringNavigator::ToAronStringPtr(const StringNavigatorPtr& navigator)
+ data::dto::AronStringPtr String::ToAronStringPtr(const StringPtr& navigator)
{
return navigator ? navigator->toAronStringPtr() : nullptr;
}
/* public member functions */
- data::AronStringPtr StringNavigator::toAronStringPtr() const
+ data::dto::AronStringPtr String::toAronStringPtr() const
{
return aron;
}
/* virtual implementations */
- std::string StringNavigator::getName() const
+ std::string String::getShortName() const
{
- return "data::AronString";
+ return "String";
+ }
+ std::string String::getFullName() const
+ {
+ return "armarx::aron::data::String";
}
- bool StringNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+ bool String::fullfillsType(const type::VariantPtr& type) const
{
return type->getDescriptor() == type::Descriptor::eString;
}
- typenavigator::NavigatorPtr StringNavigator::recalculateType() const
+ type::VariantPtr String::recalculateType() const
{
- return std::make_shared<typenavigator::StringNavigator>(getPath());
+ return std::make_shared<type::String>(getPath());
}
}
diff --git a/source/RobotAPI/libraries/aron/core/data/variant/primitive/String.h b/source/RobotAPI/libraries/aron/core/data/variant/primitive/String.h
new file mode 100644
index 0000000000000000000000000000000000000000..88f67acbc8444e6956da7f7a234541a4b854167c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/variant/primitive/String.h
@@ -0,0 +1,68 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+
+// Base class
+#include "../detail/PrimitiveVariant.h"
+
+// ArmarX
+#include "../../../type/variant/primitive/String.h"
+
+namespace armarx::aron::data
+{
+
+ class String;
+ typedef std::shared_ptr<String> StringPtr;
+
+ class String :
+ public detail::PrimitiveVariant<data::dto::AronString, std::string, String>
+ {
+ public:
+ /* constructors */
+ String(const Path& = Path());
+ String(const data::dto::AronStringPtr&, const Path& = Path());
+ String(const std::string&, const Path& = Path());
+
+ /* operators */
+ bool operator==(const String&) const override;
+ bool operator==(const StringPtr&) const override;
+
+ /* static methods */
+ static StringPtr FromAronStringPtr(const data::dto::AronStringPtr& aron);
+ static data::dto::AronStringPtr ToAronStringPtr(const StringPtr& navigator);
+
+ /* public member functions */
+ data::dto::AronStringPtr toAronStringPtr() const;
+
+ /* virtual implementations */
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+
+ virtual type::VariantPtr recalculateType() const override;
+ virtual bool fullfillsType(const type::VariantPtr&) const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.cpp b/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91f88f210b4da29ebf905a7926f0edfcdedcb329
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "RecursiveVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.h b/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cb8658dba91ffb333f91d62ef318af7e5387955
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/RecursiveVisitor.h
@@ -0,0 +1,263 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <type_traits>
+
+#include "../../Descriptor.h"
+#include "Visitor.h"
+
+namespace armarx::aron::data
+{
+ /**
+ * @see type/visitor/RecursiveVisitor.h
+ */
+ template <class RecursiveVisitorImplementation>
+ void visitRecursive(RecursiveVisitorImplementation& v, typename RecursiveVisitorImplementation::Input& o)
+ {
+ data::Descriptor descriptor = v.getDescriptor(o);
+ switch (descriptor)
+ {
+ case data::Descriptor::eList:
+ {
+ v.visitListOnEnter(o);
+ unsigned int i = 0;
+ for (auto& value : v.getListElements(o))
+ {
+ visitRecursive(v, value);
+ i++;
+ }
+ v.visitListOnExit(o);
+ return;
+ }
+ case data::Descriptor::eDict:
+ {
+ v.visitDictOnEnter(o);
+ for (auto& [key, value] : v.getDictElements(o))
+ {
+ visitRecursive(v, value);
+ }
+ v.visitDictOnExit(o);
+ return;
+ }
+ case data::Descriptor::eNDArray:
+ return v.visitNDArray(o);
+ case data::Descriptor::eInt:
+ return v.visitInt(o);
+ case data::Descriptor::eLong:
+ return v.visitLong(o);
+ case data::Descriptor::eFloat:
+ return v.visitFloat(o);
+ case data::Descriptor::eDouble:
+ return v.visitDouble(o);
+ case data::Descriptor::eString:
+ return v.visitString(o);
+ case data::Descriptor::eBool:
+ return v.visitBool(o);
+ case data::Descriptor::eUnknown:
+ return v.visitUnknown(o);
+ }
+ }
+
+ /**
+ * @see type/visitor/RecursiveVisitor.h
+ * @see data/visitor/Visitor.h
+ */
+ template <class RecursiveVisitorImplementation>
+ void visitRecursive(RecursiveVisitorImplementation& v, typename RecursiveVisitorImplementation::DataInput& o, typename RecursiveVisitorImplementation::TypeInput& t)
+ {
+ type::Descriptor descriptor = v.getDescriptor(t);
+ switch (descriptor)
+ {
+ case type::Descriptor::eList:
+ {
+ v.visitListOnEnter(o, t);
+ unsigned int i = 0;
+ for (auto& [value, acceptedType] : v.getListElements(o, t))
+ {
+ visitRecursive(v, value, acceptedType);
+ i++;
+ }
+ v.visitListOnExit(o, t);
+ return;
+ }
+ case type::Descriptor::ePair:
+ {
+ v.visitPairOnEnter(o, t);
+ auto pair = v.getPairElements(o, t);
+ auto first = pair.first;
+ auto second = pair.second;
+ visitRecursive(v, first.first, first.second);
+ visitRecursive(v, second.first, second.second);
+ v.visitPairOnExit(o, t);
+ return;
+ }
+ case type::Descriptor::eTuple:
+ {
+ v.visitTupleOnEnter(o, t);
+ unsigned int i = 0;
+ for (auto& [value, acceptedType] : v.getTupleElements(o, t))
+ {
+ visitRecursive(v, value, acceptedType);
+ i++;
+ }
+ v.visitTupleOnExit(o, t);
+ return;
+ }
+ case type::Descriptor::eDict:
+ {
+ v.visitDictOnEnter(o, t);
+ for (auto& [key, value, acceptedType] : v.getDictElements(o, t))
+ {
+ visitRecursive(v, value, acceptedType);
+ }
+ v.visitDictOnExit(o, t);
+ return;
+ }
+ case type::Descriptor::eObject:
+ {
+ v.visitObjectOnEnter(o, t);
+ for (auto& [key, value, acceptedType] : v.getObjectElements(o, t))
+ {
+ visitRecursive(v, value, acceptedType);
+ }
+ v.visitObjectOnExit(o, t);
+ return;
+ }
+ case type::Descriptor::eNDArray:
+ return v.visitNDArray(o, t);
+ case type::Descriptor::eMatrix:
+ return v.visitMatrix(o, t);
+ case type::Descriptor::eOrientation:
+ return v.visitOrientation(o, t);
+ case type::Descriptor::eImage:
+ return v.visitImage(o, t);
+ case type::Descriptor::ePointCloud:
+ return v.visitPointCloud(o, t);
+ case type::Descriptor::ePosition:
+ return v.visitPosition(o, t);
+ case type::Descriptor::ePose:
+ return v.visitPose(o, t);
+ case type::Descriptor::eQuaternion:
+ return v.visitQuaternion(o, t);
+ case type::Descriptor::eInt:
+ return v.visitInt(o, t);
+ case type::Descriptor::eLong:
+ return v.visitLong(o, t);
+ case type::Descriptor::eFloat:
+ return v.visitFloat(o, t);
+ case type::Descriptor::eDouble:
+ return v.visitDouble(o, t);
+ case type::Descriptor::eString:
+ return v.visitString(o, t);
+ case type::Descriptor::eBool:
+ return v.visitBool(o, t);
+ case type::Descriptor::eTime:
+ return v.visitTime(o, t);
+ case type::Descriptor::eIntEnum:
+ return v.visitIntEnum(o, t);
+ case type::Descriptor::eUnknown:
+ return v.visitUnknown(o, t);
+ }
+ }
+
+ /**
+ * @see type/visitor/RecursiveVisitor.h
+ */
+ template <class T>
+ struct RecursiveVisitor : virtual public VisitorBase<T>
+ {
+ using Input = typename VisitorBase<T>::Input;
+ using InputNonConst = typename std::remove_const<Input>::type;
+
+ virtual std::map<std::string, InputNonConst> getDictElements(Input&) = 0;
+ virtual std::vector<InputNonConst> getListElements(Input&) = 0;
+
+ virtual void visitDictOnEnter(Input& element) {};
+ virtual void visitDictOnExit(Input& element) {};
+ virtual void visitListOnEnter(Input& element) {};
+ virtual void visitListOnExit(Input& element) {};
+
+ virtual void visitNDArray(Input& element) {};
+ virtual void visitInt(Input& element) {};
+ virtual void visitLong(Input& element) {};
+ virtual void visitFloat(Input& element) {};
+ virtual void visitDouble(Input& element) {};
+ virtual void visitBool(Input& element) {};
+ virtual void visitString(Input& element) {};
+ virtual void visitUnknown(Input& element) { throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor."); }
+ virtual ~RecursiveVisitor() = default;
+ };
+
+ /**
+ * @see type/visitor/RecursiveVisitor.h
+ */
+ template <class T1, class T2>
+ struct RecursiveTypedVisitor : virtual public TypedVisitorBase<T1, T2>
+ {
+ using DataInput = typename TypedVisitorBase<T1, T2>::DataInput;
+ using TypeInput = typename TypedVisitorBase<T1, T2>::TypeInput;
+
+ using TypeInputNonConst = typename std::remove_const<TypeInput>::type;
+ using DataInputNonConst = typename std::remove_const<DataInput>::type;
+
+ virtual std::map<std::string, std::pair<DataInputNonConst, TypeInputNonConst>> getObjectElements(DataInput&, TypeInput&) = 0;
+ virtual std::map<std::string, std::pair<DataInputNonConst, TypeInputNonConst>> getDictElements(DataInput&, TypeInput&) = 0;
+ virtual std::vector<std::pair<DataInputNonConst, TypeInputNonConst>> getListElements(DataInput&, TypeInput&) = 0;
+ virtual std::pair<std::pair<DataInputNonConst, TypeInputNonConst>, std::pair<DataInputNonConst, TypeInputNonConst>> getPairElements(DataInput&, TypeInput&) = 0;
+ virtual std::vector<std::pair<DataInputNonConst, TypeInputNonConst>> getTupleElements(DataInput&, TypeInput&) = 0;
+
+ virtual void visitObjectOnEnter(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitObjectOnExit(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitDictOnEnter(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitDictOnExit(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitPairOnEnter(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitPairOnExit(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitTupleOnEnter(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitTupleOnExit(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitListOnEnter(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitListOnExit(DataInput& elementData, TypeInput& elementType) {};
+
+ virtual void visitMatrix(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitNDArray(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitQuaternion(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitOrientation(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitPosition(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitPose(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitImage(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitPointCloud(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitIntEnum(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitInt(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitLong(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitFloat(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitDouble(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitBool(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitString(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitTime(DataInput& elementData, TypeInput& elementType) {};
+ virtual void visitUnknown(DataInput& elementData, TypeInput& elementType) {
+ throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor.");
+ }
+ virtual ~RecursiveTypedVisitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.cpp b/source/RobotAPI/libraries/aron/core/data/visitor/Visitor.cpp
similarity index 94%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.cpp
rename to source/RobotAPI/libraries/aron/core/data/visitor/Visitor.cpp
index 1b8d9aeb079543fea479fb67e46a111910b0c4d3..016474382c0112383b19ff661a6656b4bc5d0733 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/PrimitiveSerializerBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/Visitor.cpp
@@ -22,4 +22,9 @@
*/
// Header
-#include "PrimitiveSerializerBase.h"
+#include "Visitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/Visitor.h b/source/RobotAPI/libraries/aron/core/data/visitor/Visitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2de6fd426981f56fb6c37220cbe66971d52b9fe
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/Visitor.h
@@ -0,0 +1,204 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "../../Descriptor.h"
+#include "../../Exception.h"
+
+namespace armarx::aron::data
+{
+ /**
+ * @see type/visitor/Visitor.h
+ */
+ template <class VisitorImplementation>
+ void visit(VisitorImplementation& v, typename VisitorImplementation::Input& o)
+ {
+ auto descriptor = v.getDescriptor(o);
+ switch (descriptor)
+ {
+ case data::Descriptor::eList:
+ return v.visitList(o);
+ case data::Descriptor::eDict:
+ return v.visitDict(o);
+ case data::Descriptor::eNDArray:
+ return v.visitNDArray(o);
+ case data::Descriptor::eInt:
+ return v.visitInt(o);
+ case data::Descriptor::eLong:
+ return v.visitLong(o);
+ case data::Descriptor::eFloat:
+ return v.visitFloat(o);
+ case data::Descriptor::eDouble:
+ return v.visitDouble(o);
+ case data::Descriptor::eString:
+ return v.visitString(o);
+ case data::Descriptor::eBool:
+ return v.visitBool(o);
+ case data::Descriptor::eUnknown:
+ return v.visitUnknown(o);
+ }
+ }
+
+ /**
+ * @see type/visitor/Visitor.h
+ * This implemntation visits a data and type representation simultaneously (based on the type descriptor).
+ * Does NOT check if the data and type representation match!
+ */
+ template <class VisitorImplementation>
+ void visit(VisitorImplementation& v, typename VisitorImplementation::DataInput& o, typename VisitorImplementation::TypeInput& t)
+ {
+ auto descriptor = v.getDescriptor(t);
+ switch (descriptor)
+ {
+ case type::Descriptor::eObject:
+ return v.visitObject(o, t);
+ case type::Descriptor::eList:
+ return v.visitList(o, t);
+ case type::Descriptor::eDict:
+ return v.visitDict(o, t);
+ case type::Descriptor::ePair:
+ return v.visitPair(o, t);
+ case type::Descriptor::eTuple:
+ return v.visitTuple(o, t);
+ case type::Descriptor::eNDArray:
+ return v.visitNDArray(o, t);
+ case type::Descriptor::eMatrix:
+ return v.visitMatrix(o, t);
+ case type::Descriptor::eOrientation:
+ return v.visitOrientation(o, t);
+ case type::Descriptor::eImage:
+ return v.visitImage(o, t);
+ case type::Descriptor::ePointCloud:
+ return v.visitPointCloud(o, t);
+ case type::Descriptor::ePosition:
+ return v.visitPosition(o, t);
+ case type::Descriptor::ePose:
+ return v.visitPose(o, t);
+ case type::Descriptor::eQuaternion:
+ return v.visitQuaternion(o, t);
+ case type::Descriptor::eInt:
+ return v.visitInt(o, t);
+ case type::Descriptor::eLong:
+ return v.visitLong(o, t);
+ case type::Descriptor::eFloat:
+ return v.visitFloat(o, t);
+ case type::Descriptor::eDouble:
+ return v.visitDouble(o, t);
+ case type::Descriptor::eString:
+ return v.visitString(o, t);
+ case type::Descriptor::eBool:
+ return v.visitBool(o, t);
+ case type::Descriptor::eTime:
+ return v.visitTime(o, t);
+ case type::Descriptor::eIntEnum:
+ return v.visitIntEnum(o, t);
+ case type::Descriptor::eUnknown:
+ return v.visitUnknown(o, t);
+ }
+ }
+
+ /**
+ * @see type/visitor/Visitor.h
+ */
+ template <class T>
+ struct VisitorBase
+ {
+ using Input = T;
+
+ virtual data::Descriptor getDescriptor(Input&) = 0;
+ virtual ~VisitorBase() = default;
+ };
+
+ /**
+ * @see type/visitor/Visitor.h
+ */
+ template <class T1, class T2>
+ struct TypedVisitorBase
+ {
+ using DataInput = T1;
+ using TypeInput = T2;
+
+ virtual type::Descriptor getDescriptor(TypeInput&) = 0;
+ virtual ~TypedVisitorBase() = default;
+ };
+
+ /**
+ * @see type/visitor/Visitor.h
+ */
+ template <class T>
+ struct Visitor : virtual public VisitorBase<T>
+ {
+ using Input = typename VisitorBase<T>::Input;
+
+ virtual void visitDict(Input&) {};
+ virtual void visitList(Input&) {};
+ virtual void visitNDArray(Input&) {};
+ virtual void visitInt(Input&) {};
+ virtual void visitLong(Input&) {};
+ virtual void visitFloat(Input&) {};
+ virtual void visitDouble(Input&) {};
+ virtual void visitBool(Input&) {};
+ virtual void visitString(Input&) {};
+ virtual void visitUnknown(Input&) { throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor."); }
+ virtual ~Visitor() = default;
+ };
+
+ /**
+ * @see type/visitor/Visitor.h
+ */
+ template <class T1, class T2>
+ struct TypedVisitor : virtual public TypedVisitorBase<T1, T2>
+ {
+ using DataInput = typename TypedVisitorBase<T1, T2>::DataInput;
+ using TypeInput = typename TypedVisitorBase<T1, T2>::TypeInput;
+
+ virtual void visitObject(DataInput&, TypeInput&) {};
+ virtual void visitDict(DataInput&, TypeInput&) {};
+ virtual void visitPair(DataInput&, TypeInput&) {};
+ virtual void visitTuple(DataInput&, TypeInput&) {};
+ virtual void visitList(DataInput&, TypeInput&) {};
+ virtual void visitMatrix(DataInput&, TypeInput&) {};
+ virtual void visitNDArray(DataInput&, TypeInput&) {};
+ virtual void visitQuaternion(DataInput&, TypeInput&) {};
+ virtual void visitOrientation(DataInput&, TypeInput&) {};
+ virtual void visitPosition(DataInput&, TypeInput&) {};
+ virtual void visitPose(DataInput&, TypeInput&) {};
+ virtual void visitImage(DataInput&, TypeInput&) {};
+ virtual void visitPointCloud(DataInput&, TypeInput&) {};
+ virtual void visitIntEnum(DataInput&, TypeInput&) {};
+ virtual void visitInt(DataInput&, TypeInput&) {};
+ virtual void visitLong(DataInput&, TypeInput&) {};
+ virtual void visitFloat(DataInput&, TypeInput&) {};
+ virtual void visitDouble(DataInput&, TypeInput&) {};
+ virtual void visitBool(DataInput&, TypeInput&) {};
+ virtual void visitString(DataInput&, TypeInput&) {};
+ virtual void visitTime(DataInput&, TypeInput&) {};
+ virtual void visitUnknown(DataInput&, TypeInput&) { throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor."); }
+ virtual ~TypedVisitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp b/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b2175d223a59338b77521a0f07c289ce598eca9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "NlohmannJSONVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.h b/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ff87236d2aa6221543bb488e7ec616599931bf2
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/nlohmannJSON/NlohmannJSONVisitor.h
@@ -0,0 +1,58 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+// SImox
+#include <SimoxUtility/json.h>
+
+#include "../Visitor.h"
+#include "../../../Descriptor.h"
+#include "../../rw/json/Data.h"
+
+namespace armarx::aron::data
+{
+ /**
+ * @see type/visitor/nlohmannJSON/NlohmannJSONVisitor.h
+ */
+ struct ConstNlohmannJSONVisitor : virtual public Visitor<const nlohmann::json>
+ {
+ virtual data::Descriptor getDescriptor(Input& n) override
+ {
+ if (n == nlohmann::json())
+ {
+ return data::Descriptor::eUnknown;
+ }
+ std::string t = n[armarx::aron::data::rw::json::constantes::TYPE_SLUG];
+ return armarx::aron::data::rw::json::conversion::String2Descriptor.at(t);
+ }
+
+ virtual ~ConstNlohmannJSONVisitor() = default;
+ };
+
+ // TODO
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.cpp b/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..005f9110566e3e90b6cd28d88d688ad00b51a09c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "VariantVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h b/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0e3f66e6bd0d85e1100ea241d6cc415ec0496b4
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h
@@ -0,0 +1,208 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "../RecursiveVisitor.h"
+#include "../../variant/All.h"
+
+namespace armarx::aron::data
+{
+ /**
+ * @see type/visitor/variant/VariantVisitor.h
+ */
+ struct ConstVariantVisitor : virtual public Visitor<const data::VariantPtr>
+ {
+ virtual data::Descriptor getDescriptor(Input& n) override
+ {
+ if (!n)
+ {
+ return data::Descriptor::eUnknown;
+ }
+ return n->getDescriptor();
+ }
+
+ virtual ~ConstVariantVisitor() = default;
+ };
+
+ /**
+ * @see type/visitor/variant/VariantVisitor.h
+ */
+ struct ConstTypedVariantVisitor : virtual public TypedVisitor<const data::VariantPtr, const type::VariantPtr>
+ {
+ virtual type::Descriptor getDescriptor(TypeInput& n) override
+ {
+ if (!n)
+ {
+ return type::Descriptor::eUnknown;
+ }
+ return n->getDescriptor();
+ }
+
+ virtual ~ConstTypedVariantVisitor() = default;
+ };
+
+ /**
+ * @see type/visitor/variant/VariantVisitor.h
+ */
+ struct RecursiveConstVariantVisitor : virtual public RecursiveVisitor<const data::VariantPtr>
+ {
+ virtual data::Descriptor getDescriptor(Input& n) override
+ {
+ if (!n)
+ {
+ return data::Descriptor::eUnknown;
+ }
+ return n->getDescriptor();
+ }
+
+ virtual std::map<std::string, InputNonConst> getDictElements(Input& n) override
+ {
+ auto x = data::Dict::DynamicCastAndCheck(n);
+ return x->getElements();
+ }
+
+ virtual std::vector<InputNonConst> getListElements(Input& n) override
+ {
+ auto x = data::List::DynamicCastAndCheck(n);
+ return x->getElements();
+ }
+
+ virtual ~RecursiveConstVariantVisitor() = default;
+ };
+
+ /**
+ * @see type/visitor/variant/VariantVisitor.h
+ */
+ struct RecursiveVariantVisitor : virtual public RecursiveVisitor<data::VariantPtr>
+ {
+ virtual data::Descriptor getDescriptor(Input& n) override
+ {
+ if (!n)
+ {
+ return data::Descriptor::eUnknown;
+ }
+ return n->getDescriptor();
+ }
+
+ virtual std::map<std::string, InputNonConst> getDictElements(Input& n) override
+ {
+ auto x = data::Dict::DynamicCastAndCheck(n);
+ return x->getElements();
+ }
+
+ virtual std::vector<InputNonConst> getListElements(Input& n) override
+ {
+ auto x = data::List::DynamicCastAndCheck(n);
+ return x->getElements();
+ }
+
+ virtual ~RecursiveVariantVisitor() = default;
+ };
+
+ /**
+ * @see type/visitor/variant/VariantVisitor.h
+ */
+ struct RecursiveConstTypedVariantVisitor : virtual public RecursiveTypedVisitor<const data::VariantPtr, const type::VariantPtr>
+ {
+ virtual type::Descriptor getDescriptor(TypeInput& n) override
+ {
+ if (!n)
+ {
+ return type::Descriptor::eUnknown;
+ }
+ return n->getDescriptor();
+ }
+
+ virtual std::map<std::string, std::pair<DataInputNonConst, TypeInputNonConst>> getObjectElements(DataInput& o, TypeInput& t) override
+ {
+ std::map<std::string, std::pair<data::VariantPtr, type::VariantPtr>> ret;
+ auto x = data::Dict::DynamicCastAndCheck(o);
+ auto y = type::Object::DynamicCastAndCheck(t);
+ for (const auto& [key, e] : x->getElements())
+ {
+ auto ct = y->getMemberType(key);
+ ret.insert({key, {e, ct}});
+ }
+ return ret;
+ }
+ virtual std::map<std::string, std::pair<DataInputNonConst, TypeInputNonConst>> getDictElements(DataInput& o, TypeInput& t) override
+ {
+ std::map<std::string, std::pair<data::VariantPtr, type::VariantPtr>> ret;
+ auto x = data::Dict::DynamicCastAndCheck(o);
+ auto y = type::Dict::DynamicCastAndCheck(t);
+ auto ac = y->getAcceptedType();
+
+ for (const auto& [key, e] : x->getElements())
+ {
+ ret.insert({key, {e, ac}});
+ }
+ return ret;
+ }
+ virtual std::vector<std::pair<DataInputNonConst, TypeInputNonConst>> getListElements(DataInput& o, TypeInput& t) override
+ {
+ std::vector<std::pair<data::VariantPtr, type::VariantPtr>> ret;
+ auto x = data::List::DynamicCastAndCheck(o);
+ auto y = type::List::DynamicCastAndCheck(t);
+ auto ac = y->getAcceptedType();
+
+ for (const auto& e : x->getElements())
+ {
+ ret.push_back({e, ac});
+ }
+ return ret;
+ }
+ virtual std::pair<std::pair<DataInputNonConst, TypeInputNonConst>, std::pair<DataInputNonConst, TypeInputNonConst>>
+ getPairElements(DataInput& o, TypeInput& t) override
+ {
+ auto x = data::List::DynamicCastAndCheck(o);
+ auto y = type::Pair::DynamicCastAndCheck(t);
+
+ auto e0 = x->getElement(0);
+ auto ac0 = y->getFirstAcceptedType();
+ auto e1 = x->getElement(1);
+ auto ac1 = y->getSecondAcceptedType();
+ return {{e0, ac0}, {e1, ac1}};
+ }
+ virtual std::vector<std::pair<DataInputNonConst, TypeInputNonConst>> getTupleElements(DataInput& o, TypeInput& t) override
+ {
+ std::vector<std::pair<data::VariantPtr, type::VariantPtr>> ret;
+ auto x = data::List::DynamicCastAndCheck(o);
+ auto y = type::Tuple::DynamicCastAndCheck(t);
+
+ unsigned int i = 0;
+ for (const auto& e : x->getElements())
+ {
+ auto ac = y->getAcceptedType(i++);
+ ret.push_back({e, ac});
+ }
+ return ret;
+ }
+
+ virtual ~RecursiveConstTypedVariantVisitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/io/Data.h b/source/RobotAPI/libraries/aron/core/io/Data.h
deleted file mode 100644
index e1c3cfcf026ba5019d5147e9c00cc2335c717065..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/Data.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <ArmarXCore/core/exceptions/Exception.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-
-
-namespace armarx::aron::io
-{
- class Data
- {
- private:
- Data() = delete;
-
- public:
- static constexpr const char* READER_WRITER_MAYBE_SLUG = "__ARON_MAYBE";
- static constexpr const char* READER_WRITER_TYPE_SLUG = "__ARON_TYPE";
- static constexpr const char* READER_WRITER_VERSION_SLUG = "__ARON_VERSION";
-
- static constexpr const char* READER_WRITER_VALUE_SLUG = "__ARON_VALUE";
-
- static constexpr const char* READER_WRITER_OBJECT_NAME_SLUG = "__ARON_OBJECT_NAME";
- static constexpr const char* READER_WRITER_OBJECT_EXTENDS_SLUG = "__ARON_OBJECT_EXTENDS";
-
- static constexpr const char* READER_WRITER_DICT_ACCEPTED_TYPE_SLUG = "__ARON_DICT_ACCEPTED_TYPE";
- static constexpr const char* READER_WRITER_LIST_ACCEPTED_TYPE_SLUG = "__ARON_LIST_ACCEPTED_TYPE";
-
- static constexpr const char* READER_WRITER_NDARRAY_NAME_SLUG = "__ARON_NDARRAY_NAME";
- static constexpr const char* READER_WRITER_NDARRAY_DIMENSIONS_SLUG = "__ARON_NDARRAY_DIMESIONS";
- static constexpr const char* READER_WRITER_NDARRAY_TYPE_SLUG = "__ARON_NDARRAY_TYPE";
- static constexpr const char* READER_WRITER_NDARRAY_DATA_SLUG = "__ARON_NDARRAY_DATA";
-
- static constexpr const char* READER_WRITER_INT_ENUM_NAME_SLUG = "__ARON_INT_ENUM_NAME";
- static constexpr const char* READER_WRITER_ENUM_KEY_SLUG = "__ARON_ENUM_KEY";
-
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- static constexpr const char* READER_WRITER_##capsType##_TYPENAME_SLUG = #capsType;
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/Reader.h b/source/RobotAPI/libraries/aron/core/io/dataIO/Reader.h
deleted file mode 100644
index e2769dd1c0f19152ec635c08ee7d580f223fab9f..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/Reader.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-#include <vector>
-#include <optional>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron::dataIO
-{
- class ReaderInterface;
- typedef std::shared_ptr<ReaderInterface> ReaderInterfacePtr;
-
- class ReaderInterface
- {
- public:
- struct ReadStartDictReturnType
- {
- int elements;
- bool success;
- };
- virtual ReadStartDictReturnType readStartDict() = 0;
- virtual bool readEndDict() = 0;
-
- struct ReadStartListReturnType
- {
- int elements;
- bool success;
- };
- virtual ReadStartListReturnType readStartList() = 0;
- virtual bool readEndList() = 0;
-
- struct ReadStartNDArrayReturnType
- {
- std::vector<int> dims;
- std::string type;
- bool success;
- };
- virtual ReadStartNDArrayReturnType readStartNDArray() = 0;
- virtual void readEndNDArray(unsigned char*) = 0;
-
- struct ReadPrimitiveReturnType
- {
- bool success;
- };
- virtual ReadPrimitiveReturnType readStartPrimitive() = 0;
- virtual void readEndPrimitive(int&) = 0;
- virtual void readEndPrimitive(long&) = 0;
- virtual void readEndPrimitive(float&) = 0;
- virtual void readEndPrimitive(double&) = 0;
- virtual void readEndPrimitive(std::string&) = 0;
- virtual void readEndPrimitive(bool&) = 0;
-
- virtual std::string readKey() = 0;
- virtual void loadMember(const std::string&) = 0;
-
- // This method is for converters or visitors. The code generation knows what to call (e.g. readStartNDArray) since it knows the type.
- // But if the type is unknown (and null), we need a method to increase the cnt of a token to the next element
- virtual void readNull() = 0;
-
- // Helper functions
- virtual data::Descriptor getTypeOfNext() const = 0;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/Writer.h b/source/RobotAPI/libraries/aron/core/io/dataIO/Writer.h
deleted file mode 100644
index 0cd1caec4d0b515a104eeb935f23df946e1b6db3..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/Writer.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron::dataIO
-{
- class WriterInterface;
- typedef std::shared_ptr<WriterInterface> WriterInterfacePtr;
-
- class WriterInterface
- {
- public:
- virtual void writeStartDict() = 0;
- virtual void writeEndDict() = 0;
- virtual void writeStartList() = 0;
- virtual void writeEndList() = 0;
-
- virtual void writeNDArray(const std::vector<int>&, const std::string&, const unsigned char*) = 0;
-
- virtual void writePrimitive(int) = 0;
- virtual void writePrimitive(long) = 0;
- virtual void writePrimitive(float) = 0;
- virtual void writePrimitive(double) = 0;
- virtual void writePrimitive(const std::string&) = 0;
- virtual void writePrimitive(bool) = 0;
-
- virtual void writeNull() = 0;
-
- virtual void writeKey(const std::string&) = 0;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.cpp
deleted file mode 100644
index b8dbb60419279e56ca1a8c9cdb2d6db286a64550..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "Converter.h"
-
-#include <RobotAPI/libraries/aron/core/Debug.h>
-
-
-
-namespace armarx::aron::dataIO
-{
- void Converter::ReadAndConvert(ReaderInterface& reader, WriterInterface& writer, const aron::typenavigator::NavigatorPtr& expectedStructure)
- {
- type::Descriptor t_desc = expectedStructure != nullptr ? expectedStructure->getDescriptor() : type::Descriptor::eUnknown;
- //std::cout << "Expected Structure: " << type::DESCRIPTOR_TO_STRING(t_desc) << std::endl;
- data::Descriptor desc = reader.getTypeOfNext();
-
- // TODO check expected type and read type
-
- switch (desc)
- {
- case data::Descriptor::eDict:
- {
- auto readStartDict = reader.readStartDict();
- writer.writeStartDict();
-
- typenavigator::NavigatorPtr childType = nullptr;
- if (t_desc == type::Descriptor::eDict)
- {
- auto t = typenavigator::DictNavigator::DynamicCastAndCheck(expectedStructure);
- childType = t->getAcceptedType();
- }
-
- for (int i = 0; i < readStartDict.elements; ++i)
- {
- std::string key = reader.readKey();
- writer.writeKey(key);
-
- if (t_desc == type::Descriptor::eObject)
- {
- auto t = typenavigator::ObjectNavigator::DynamicCastAndCheck(expectedStructure);
- childType = t->getMemberType(key);
- }
-
- Converter::ReadAndConvert(reader, writer, childType);
- }
-
- writer.writeEndDict();
- reader.readEndDict();
-
- break;
- }
- case data::Descriptor::eList:
- {
- auto readStartList = reader.readStartList();
- writer.writeStartList();
-
- typenavigator::NavigatorPtr childType = nullptr;
- if (t_desc == type::Descriptor::eList)
- {
- auto t = typenavigator::ListNavigator::DynamicCastAndCheck(expectedStructure);
- childType = t->getAcceptedType();
- }
-
- for (int i = 0; i < readStartList.elements; ++i)
- {
- if (t_desc == type::Descriptor::eObject)
- {
- auto t = typenavigator::TupleNavigator::DynamicCastAndCheck(expectedStructure);
- childType = t->getAcceptedType(i);
- }
-
- Converter::ReadAndConvert(reader, writer, childType);
- }
-
- writer.writeEndList();
- reader.readEndList();
- break;
- }
-
- case data::Descriptor::eNDArray:
- {
- auto readStartNDArray = reader.readStartNDArray();
- int elements = std::accumulate(std::begin(readStartNDArray.dims), std::end(readStartNDArray.dims), 1, std::multiplies<int>());
- std::vector<unsigned char> data(elements);
- reader.readEndNDArray(data.data());
-
- writer.writeNDArray(readStartNDArray.dims, readStartNDArray.type, data.data());
- break;
- }
-
- case data::Descriptor::eInt:
- {
- int val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
- case data::Descriptor::eLong:
- {
- long val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
- case data::Descriptor::eFloat:
- {
- float val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
- case data::Descriptor::eDouble:
- {
- double val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
- case data::Descriptor::eString:
- {
- std::string val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
- case data::Descriptor::eBool:
- {
- bool val;
- reader.readEndPrimitive(val);
- writer.writePrimitive(val);
- break;
- }
-
- case data::Descriptor::eUnknown:
- {
- // it seems like we found an optional value
- if (t_desc != type::Descriptor::eUnknown && expectedStructure->getMaybe() == type::Maybe::eNone)
- {
- throw error::DescriptorNotValidException("Converter", "ReadAndConvert", "The Descriptor is unknown but the expected type assumes a non-maybe type!", desc);
- }
- reader.readNull();
- writer.writeNull();
- }
- }
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.h b/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.h
deleted file mode 100644
index 1ea6c6f5c3bf984d2fad6b8ffd55f7cc7d50f76c..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/converter/Converter.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/Reader.h>
-
-
-namespace armarx::aron::dataIO
-{
- class Converter;
- typedef std::shared_ptr<Converter> ConverterPtr;
-
- class Converter
- {
- private:
- Converter() = delete;
-
- public:
- static void ReadAndConvert(ReaderInterface&, WriterInterface&, const aron::typenavigator::NavigatorPtr& expectedStructure = nullptr);
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/ReaderToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/ReaderToken.h
deleted file mode 100644
index d9f2a7bde5ec5bb45278b36e6fb9f73165de6732..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/ReaderToken.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Simox
-#include <SimoxUtility/algorithm/string.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/io/Data.h>
-
-namespace armarx::aron::dataIO
-{
- template<typename ElementTypename>
- class ReaderTokenInterface;
-
- template<typename ElementTypename>
- using ReaderTokenInterfacePtr = std::shared_ptr<ReaderTokenInterface<ElementTypename>>;
-
- template<typename ElementTypename>
- class ReaderTokenInterface
- {
- public:
- using PointerType = ReaderTokenInterfacePtr<ElementTypename>;
-
-
- // Interface
- virtual data::Descriptor getTypeOfNext() const = 0;
- virtual ElementTypename getNextElement() const = 0;
- virtual bool hasNextElement() const = 0;
-
- // General implementation
- ElementTypename getElement() const
- {
- return element;
- }
-
- data::Descriptor getDescriptor() const
- {
- return descriptor;
- }
-
- unsigned int getElementChildrenSize() const
- {
- return childrenSize;
- }
-
- bool finishedElement() const
- {
- return currentIndex >= getElementChildrenSize();
- }
-
- std::string getCurrentKey() const
- {
- assertIndexInBounds();
-
- // ugly workaround
- if (this->currentKey == "") // probably in a dict where the caller does not know which keys are there
- {
- if (this->allMemberNames.size() == 0)
- {
- throw error::AronException("dataIO::ReaderTokenInterface", "getCurrentKey", "The currentKey is not set and the list of all keys is empty!");
- }
- return this->allMemberNames[this->currentIndex];
- }
- return this->currentKey;
- }
-
- bool hasKey(const std::string& k) const
- {
- if (descriptor != data::Descriptor::eDict)
- {
- throw error::DescriptorNotValidException("ReaderTokenInterface", "hasKey", "Checking whether a container has a key only makes sense in a dict.", descriptor);
- }
- return std::find(allMemberNames.begin(), allMemberNames.end(), k) != allMemberNames.end();
- }
-
- void setCurrentKey(const std::string& s)
- {
- currentKey = s;
- }
-
- void assertType(data::Descriptor t) const
- {
- if (descriptor != t)
- {
- throw error::DescriptorNotValidException("dataIO::ReaderTokenInterface", "assertType", "The type was not equal.", t);
- }
- }
-
- void assertIndexInBounds() const
- {
- if (this->currentIndex >= getElementChildrenSize())
- {
- throw error::SizeNotValidException("dataIO::ReaderTokenInterface", "assertIndexInBounds", "Index out of bounds.", this->currentIndex, getElementChildrenSize());
- }
- }
-
- void increaseCounter()
- {
- this->currentIndex++;
- }
-
- unsigned int getCurrentIndex() const
- {
- return currentIndex;
- }
-
- std::string allMemberNamesToString() const
- {
- return simox::alg::to_string(allMemberNames, ", ");
- }
-
-
- protected:
- // members
- data::Descriptor descriptor = data::Descriptor::eUnknown;
- ElementTypename element;
-
- unsigned int childrenSize = 0;
- unsigned int currentIndex = 0;
-
- std::string currentKey = "";
- std::vector<std::string> allMemberNames = {};
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.cpp
deleted file mode 100644
index d5e2ebe0fe9eb12a834bef86cd673faa41369912..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "NavigatorReader.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-
-
-namespace armarx::aron::dataIO::reader
-{
- NavigatorReader::NavigatorReader(const data::AronDictPtr& n) :
- NavigatorReader(datanavigator::DictNavigator::DynamicCastAndCheck(datanavigator::Navigator::FromAronData(n)))
- {
- }
-
- NavigatorReader::NavigatorReader(const datanavigator::DictNavigatorPtr& n) :
- input(n)
- {
- auto current_nav_casted = datanavigator::DictNavigator::DynamicCastAndCheck(input);
- auto newToken = std::make_shared<NavigatorReaderToken>(current_nav_casted);
- stack.push(newToken);
- }
-
- // Containers
- ReaderInterface::ReadStartDictReturnType NavigatorReader::readStartDict()
- {
- if (!readFirstStartDict)
- {
- // we already added in constructor
- readFirstStartDict = true;
- auto lastToken = stack.top();
- auto current_nav = lastToken->getElement();
- int c = current_nav->childrenSize();
- return {c, true};
- }
-
- auto lastToken = stack.top();
-
- auto current_nav = lastToken->getNextElement();
- if (!current_nav)
- {
- lastToken->increaseCounter();
- return {0, false};
- }
-
- auto current_nav_casted = datanavigator::DictNavigator::DynamicCastAndCheck(current_nav);
- int c = current_nav->childrenSize();
- auto newToken = std::make_shared<NavigatorReaderToken>(current_nav_casted);
- stack.push(newToken);
- return {c, true};
- }
-
- bool NavigatorReader::readEndDict()
- {
- auto token = stack.top();
- datanavigator::DictNavigator::DynamicCastAndCheck(token->getElement());
-
- //std::cout << "We are at: " << token->getCurrentIndex() << "/" << token->getElementChildrenSize() << std::endl;
-
- if (token->finishedElement())
- {
- stack.pop();
-
- if (!stack.empty())
- {
- auto lastToken = stack.top();
- lastToken->increaseCounter();
- }
-
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartListReturnType NavigatorReader::readStartList()
- {
- auto lastToken = stack.top();
-
- auto current_nav = lastToken->getNextElement();
- if (!current_nav)
- {
- lastToken->increaseCounter();
- return {0, false};
- }
-
- auto current_nav_casted = datanavigator::ListNavigator::DynamicCastAndCheck(current_nav);
- int c = current_nav->childrenSize();
- auto newToken = std::make_shared<NavigatorReaderToken>(current_nav_casted);
- stack.push(newToken);
- return {c, true};
- }
-
- bool NavigatorReader::readEndList()
- {
- auto token = stack.top();
- datanavigator::ListNavigator::DynamicCastAndCheck(token->getElement());
-
- //std::cout << "We are at: " << token->getCurrentIndex() << "/" << token->getElementChildrenSize() << std::endl;
- if (token->finishedElement())
- {
- stack.pop();
-
- auto lastToken = stack.top();
- lastToken->increaseCounter();
-
- return true;
- }
- return false;
- }
-
- // Complex Data
- ReaderInterface::ReadStartNDArrayReturnType NavigatorReader::readStartNDArray()
- {
- auto lastToken = stack.top();
-
- auto current_nav = lastToken->getNextElement();
- if (!current_nav)
- {
- lastToken->increaseCounter();
- return {{}, "", false};
- }
- datanavigator::NDArrayNavigatorPtr casted = datanavigator::NDArrayNavigator::DynamicCastAndCheck(current_nav);
- return {casted->getDimensions(), casted->getType(), true};
- }
-
- void NavigatorReader::readEndNDArray(unsigned char* data)
- {
- if (data == nullptr)
- {
- throw error::AronException("NavigatorReader", "readEndNDArray", "The corresponding data pointer of an complex aron ptr is NULL.");
- }
-
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::NDArrayNavigator::DynamicCastAndCheck(current_nav);
- std::vector<int> dims = casted->getDimensions();
- int size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
- std::memcpy(data, casted->getData(), static_cast<size_t>(size));
- }
-
- // Read primitives
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readStartPrimitive()
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- if (!current_nav)
- {
- lastToken->increaseCounter();
- return {false};
- }
- return {true};
- }
-
- void NavigatorReader::readEndPrimitive(int& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::IntNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- void NavigatorReader::readEndPrimitive(long& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::LongNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- void NavigatorReader::readEndPrimitive(float& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::FloatNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- void NavigatorReader::readEndPrimitive(double& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::DoubleNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- void NavigatorReader::readEndPrimitive(std::string& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::StringNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- void NavigatorReader::readEndPrimitive(bool& t)
- {
- auto lastToken = stack.top();
- auto current_nav = lastToken->getNextElement();
- lastToken->increaseCounter();
-
- auto casted = datanavigator::BoolNavigator::DynamicCastAndCheck(current_nav);
- t = casted->getValue();
- }
-
- std::string NavigatorReader::readKey()
- {
- auto token = stack.top();
- auto s = token->getCurrentKey();
- //std::cout << "Read key: " << s << std::endl;
- return s;
- }
-
- void NavigatorReader::loadMember(const std::string& k)
- {
- //std::cout << "Loading member " << k << std::endl;
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- void NavigatorReader::readNull()
- {
- auto token = stack.top();
- auto current_nav = token->getNextElement();
- if (!current_nav)
- {
- throw error::AronException("NavigatorReader", "readNull", "The value of a navigator is not null!");
- }
- token->increaseCounter();
- }
-
- // Helper functions
- data::Descriptor NavigatorReader::getTypeOfNext() const
- {
- if (stack.empty())
- {
- return data::Descriptor::eDict;
- }
- auto token = stack.top();
- return token->getTypeOfNext();
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.h b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.h
deleted file mode 100644
index 26f7628de7747d030f9f7f38a4ca9d2c3fa5ac39..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <stack>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/io/dataIO/Reader.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReaderToken.h>
-
-
-namespace armarx::aron::dataIO::reader
-{
- class NavigatorReader;
- typedef std::shared_ptr<NavigatorReader> NavigatorReaderPtr;
-
- class NavigatorReader :
- virtual public ReaderInterface
- {
- public:
- using PointerType = NavigatorReaderPtr;
-
- // constructors
- NavigatorReader() = delete;
- NavigatorReader(const datanavigator::DictNavigatorPtr& n);
- NavigatorReader(const data::AronDictPtr& n);
-
- virtual ReadStartDictReturnType readStartDict() override;
- virtual bool readEndDict() override;
-
- virtual ReadStartListReturnType readStartList() override;
- virtual bool readEndList() override;
-
- virtual ReadStartNDArrayReturnType readStartNDArray() override;
- virtual void readEndNDArray(unsigned char*) override;
-
- virtual ReadPrimitiveReturnType readStartPrimitive() override;
- virtual void readEndPrimitive(int&) override;
- virtual void readEndPrimitive(long&) override;
- virtual void readEndPrimitive(float&) override;
- virtual void readEndPrimitive(double&) override;
- virtual void readEndPrimitive(std::string&) override;
- virtual void readEndPrimitive(bool&) override;
-
- virtual std::string readKey() override;
- virtual void loadMember(const std::string&) override;
-
- virtual void readNull() override;
-
- virtual data::Descriptor getTypeOfNext() const override;
-
- private:
- bool readFirstStartDict = false;
- datanavigator::NavigatorPtr input;
- std::stack<NavigatorReaderTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReaderToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReaderToken.h
deleted file mode 100644
index 6941b5f4ec9c3e2566a7717e7675c673399a171d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReaderToken.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/ReaderToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-namespace armarx::aron::dataIO::reader
-{
- // BaseClass
- class NavigatorReaderToken;
- typedef std::shared_ptr<NavigatorReaderToken> NavigatorReaderTokenPtr;
-
- class NavigatorReaderToken :
- virtual public ReaderTokenInterface<datanavigator::NavigatorPtr>
- {
- public:
- using PointerType = NavigatorReaderTokenPtr;
-
- public:
- // constructors
- NavigatorReaderToken() = delete;
- NavigatorReaderToken(const datanavigator::NavigatorPtr& data)
- {
- descriptor = data->getDescriptor();
- element = data;
-
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- allMemberNames = datanavigator::DictNavigator::DynamicCastAndCheck(data)->getAllKeys();
- childrenSize = data->childrenSize();
- break;
- }
- case data::Descriptor::eList:
- {
- childrenSize = data->childrenSize();
- break;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorReaderToken", "NavigatorReaderToken", "Received an invalid instance for a reader token.", descriptor);
- }
- }
-
- data::Descriptor getTypeOfNext() const override
- {
- const datanavigator::NavigatorPtr next = getNextElement();
- return next->getDescriptor();
- }
-
- datanavigator::NavigatorPtr getNextElement() const override
- {
- if (!hasNextElement())
- {
- return nullptr;
- }
-
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- datanavigator::DictNavigatorPtr casted = datanavigator::DictNavigator::DynamicCast(element);
- datanavigator::NavigatorPtr ret = casted->getElement(getCurrentKey());
- return ret;
- }
- case data::Descriptor::eList:
- {
- datanavigator::ListNavigatorPtr casted = datanavigator::ListNavigator::DynamicCast(element);
- datanavigator::NavigatorPtr ret = casted->getElement(currentIndex);
- return ret;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorReaderToken", "getNextElement", "Could not resove a type of a navigator. Allowed are only container types due to performance", descriptor);
- }
- }
-
- virtual bool hasNextElement() const override
- {
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- datanavigator::DictNavigatorPtr casted = datanavigator::DictNavigator::DynamicCast(element);
- datanavigator::NavigatorPtr ret = casted->getElement(getCurrentKey());
- return (bool) ret;
- }
- case data::Descriptor::eList:
- {
- datanavigator::ListNavigatorPtr casted = datanavigator::ListNavigator::DynamicCast(element);
- datanavigator::NavigatorPtr ret = casted->getElement(currentIndex);
- return (bool) ret;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorReaderToken", "hasData", "Could not resove a type of a navigator. Allowed are only container types due to performance", descriptor);
- }
- }
-
- private:
-
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
deleted file mode 100644
index a17cc3ed151006531771e31e4639db4a972d34d5..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "NlohmannJSONReader.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-
-
-namespace armarx::aron::dataIO::reader
-{
- NlohmannJSONReader::NlohmannJSONReader(const std::string& n) :
- NlohmannJSONReader(nlohmann::json::parse(n))
- {
- }
-
- NlohmannJSONReader::NlohmannJSONReader(const nlohmann::json& n) :
- input(n)
- {
- if (!n.is_object())
- {
- throw error::AronException("NlohmannJSONReader", "NlohmannJSONReader", "Allowed are only objects in reader. Got as json: " + n.dump(2));
- }
-
- if (n.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_DICT_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readStartList", "The json is not of dict type!", n[io::Data::READER_WRITER_TYPE_SLUG], io::Data::READER_WRITER_DICT_TYPENAME_SLUG);
- }
-
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(n);
- stack.push(newToken);
- }
-
- ReaderInterface::ReadStartDictReturnType NlohmannJSONReader::readStartDict()
- {
- auto lastToken = stack.top();
- if (!readFirstStartDict)
- {
- // we already added in constructor
- readFirstStartDict = true;
- auto current_json = lastToken->getElement();
- int c = lastToken->getElementChildrenSize();
- return {c, true};
- }
-
- auto current_json = lastToken->getNextElement();
- if (current_json.is_null())
- {
- lastToken->increaseCounter(); // no need to call readEndDict anymore
- return {0, false};
- }
-
- if (!current_json.is_object())
- {
- throw error::AronException("NlohmannJSONReader", "readStartDict", "The json is not an object. Every part of the data must be an object containing the type and the value.");
- }
-
- if (current_json.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_DICT_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readStartList", "The json is not of dict type!", current_json.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_DICT_TYPENAME_SLUG);
- }
-
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(current_json);
- int c = newToken->getElementChildrenSize();
- stack.push(newToken);
- return {c, true};
- }
-
- bool NlohmannJSONReader::readEndDict()
- {
- auto token = stack.top();
- token->assertType(data::Descriptor::eDict);
-
- if (token->finishedElement())
- {
- stack.pop();
-
- if (!stack.empty())
- {
- auto lastToken = stack.top();
- lastToken->increaseCounter();
- }
-
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartListReturnType NlohmannJSONReader::readStartList()
- {
- auto lastToken = stack.top();
-
- auto current_json = lastToken->getNextElement();
- if (current_json.is_null())
- {
- lastToken->increaseCounter(); // no need to call readEndList anymore
- return {0, false};
- }
-
- if (!current_json.is_object())
- {
- throw error::AronException("NlohmannJSONReader", "readStartList", "The json is not an object. Every part of the data must be an object containing the type and the value.");
- }
-
- if (current_json.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_LIST_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readStartList", "The json is not of list type!", current_json.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_LIST_TYPENAME_SLUG);
- }
-
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(current_json);
- int c = newToken->getElementChildrenSize();
- stack.push(newToken);
- return {c, true};
- }
-
- bool NlohmannJSONReader::readEndList()
- {
- auto token = stack.top();
- token->assertType(data::Descriptor::eList);
-
- if (token->finishedElement())
- {
- stack.pop();
-
- auto lastToken = stack.top();
- lastToken->increaseCounter();
-
- return true;
- }
- return false;
- }
-
- // Complex Data
- ReaderInterface::ReadStartNDArrayReturnType NlohmannJSONReader::readStartNDArray()
- {
- auto lastToken = stack.top();
-
- auto current_json = lastToken->getNextElement();
- if (current_json.is_null())
- {
- lastToken->increaseCounter();
- return {{}, "", false};
- }
-
- if (current_json.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_NDARRAY_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readStartNDArray", "The json is not of ndarray type!", current_json.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_NDARRAY_TYPENAME_SLUG);
- }
-
- std::vector<int> dims = current_json.at(io::Data::READER_WRITER_NDARRAY_DIMENSIONS_SLUG);
- std::string type = current_json.at(io::Data::READER_WRITER_NDARRAY_TYPE_SLUG);
- return {dims, type, true};
- }
-
- void NlohmannJSONReader::readEndNDArray(unsigned char* data)
- {
- if (data == NULL)
- {
- throw error::AronException("NlohmannJSONReader", "readEndNDArray", "The corresponding data pointer of an complex aron ptr is NULL.");
- }
-
- auto lastToken = stack.top();
-
- auto current_json = lastToken->getNextElement();
- std::vector<int> dims = current_json.at(io::Data::READER_WRITER_NDARRAY_DIMENSIONS_SLUG);
- std::vector<unsigned char> d = current_json.at(io::Data::READER_WRITER_NDARRAY_DATA_SLUG);
- memcpy(data, d.data(), std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()));
- lastToken->increaseCounter();
- }
-
- // Read primitives
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readStartPrimitive()
- {
- auto lastToken = stack.top();
-
- auto current_json = lastToken->getNextElement();
- if (current_json.is_null())
- {
- lastToken->increaseCounter();
- return {false};
- }
-
- return {true};
- }
-
- void NlohmannJSONReader::readEndPrimitive(int& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_INT_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of int type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_INT_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- void NlohmannJSONReader::readEndPrimitive(long& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_LONG_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of long type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_LONG_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- void NlohmannJSONReader::readEndPrimitive(float& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_FLOAT_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of float type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_FLOAT_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- void NlohmannJSONReader::readEndPrimitive(double& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_DOUBLE_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of double type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_DOUBLE_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- void NlohmannJSONReader::readEndPrimitive(std::string& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_STRING_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of string type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_STRING_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- void NlohmannJSONReader::readEndPrimitive(bool& t)
- {
- auto lastToken = stack.top();
- auto j = lastToken->getNextElement();
-
- if (j.at(io::Data::READER_WRITER_TYPE_SLUG) != io::Data::READER_WRITER_BOOL_TYPENAME_SLUG)
- {
- throw error::StringNotValidException("NlohmannJSONReader", "readEndPrimitive", "The json is not of bool type!", j.at(io::Data::READER_WRITER_TYPE_SLUG), io::Data::READER_WRITER_BOOL_TYPENAME_SLUG);
- }
-
- lastToken->increaseCounter();
- t = j.at(io::Data::READER_WRITER_VALUE_SLUG);
- }
-
- std::string NlohmannJSONReader::readKey()
- {
- auto token = stack.top();
- return token->getCurrentKey();
- }
-
- void NlohmannJSONReader::loadMember(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- void NlohmannJSONReader::readNull()
- {
- auto token = stack.top();
- auto current_json = token->getNextElement();
- if (!current_json.is_null())
- {
- throw error::AronException("NlohmannJSONReader", "readNull", "The value of a json is not null!");
- }
- token->increaseCounter();
- }
-
- // Helper functions
- data::Descriptor NlohmannJSONReader::getTypeOfNext() const
- {
- if (stack.empty())
- {
- return data::Descriptor::eDict;
- }
- auto token = stack.top();
- return token->getTypeOfNext();
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h
deleted file mode 100644
index c2cf0b3ef9ea8fdb2fc6efeecedfd27bd5ea852b..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <stack>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/io/dataIO/Reader.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h>
-
-namespace armarx::aron::dataIO::reader
-{
- class NlohmannJSONReader;
- typedef std::shared_ptr<NlohmannJSONReader> NlohmannJSONReaderPtr;
-
- class NlohmannJSONReader :
- virtual public ReaderInterface
- {
- public:
- using PointerType = NlohmannJSONReaderPtr;
-
- // constructors
- NlohmannJSONReader() = delete;
- NlohmannJSONReader(const nlohmann::json& n);
- NlohmannJSONReader(const std::string& n);
-
- virtual ReadStartDictReturnType readStartDict() override;
- virtual bool readEndDict() override;
-
- virtual ReadStartListReturnType readStartList() override;
- virtual bool readEndList() override;
-
- virtual ReadStartNDArrayReturnType readStartNDArray() override;
- virtual void readEndNDArray(unsigned char*) override;
-
- virtual ReadPrimitiveReturnType readStartPrimitive() override;
- virtual void readEndPrimitive(int&) override;
- virtual void readEndPrimitive(long&) override;
- virtual void readEndPrimitive(float&) override;
- virtual void readEndPrimitive(double&) override;
- virtual void readEndPrimitive(std::string&) override;
- virtual void readEndPrimitive(bool&) override;
-
- virtual std::string readKey() override;
- virtual void loadMember(const std::string&) override;
-
- virtual void readNull() override;
-
- virtual data::Descriptor getTypeOfNext() const override;
-
- private:
- bool readFirstStartDict = false;
- nlohmann::json input;
- std::stack<NlohmannJSONReaderTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
deleted file mode 100644
index 0e273108d6944bbabad1e3a34d57e22177e5a138..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/ReaderToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Resolver.h>
-
-
-
-namespace armarx::aron::dataIO::reader
-{
- // BaseClass
- class NlohmannJSONReaderToken;
- typedef std::shared_ptr<NlohmannJSONReaderToken> NlohmannJSONReaderTokenPtr;
-
- class NlohmannJSONReaderToken :
- virtual public ReaderTokenInterface<nlohmann::json>
- {
- public:
- using PointerType = NlohmannJSONReaderTokenPtr;
-
- // constructors
- NlohmannJSONReaderToken() = delete;
- NlohmannJSONReaderToken(const nlohmann::json& data)
- {
- if (!data.is_object())
- {
- throw error::AronException("NlohmannJSONReaderToken", "NlohmannJSONReaderToken", "Received an invalid json instance for a reader. Allowed are only objects.");
- }
-
- descriptor = data::STRING_TO_DESCRIPTOR(data.at(io::Data::READER_WRITER_TYPE_SLUG));
- element = data;
-
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- for (auto it = data.begin(); it != data.end(); ++it)
- {
- if (it.key() == io::Data::READER_WRITER_TYPE_SLUG || it.key() == io::Data::READER_WRITER_VERSION_SLUG)
- {
- continue;
- }
- allMemberNames.push_back(it.key());
- }
- childrenSize = allMemberNames.size();
- break;
- }
- case data::Descriptor::eList:
- {
- childrenSize = data.at(io::Data::READER_WRITER_VALUE_SLUG).size();
- break;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONReaderToken", "NlohmannJSONReaderToken", "Received an invalid instance for a reader token.", descriptor);
- }
- }
-
- data::Descriptor getTypeOfNext() const override
- {
- const nlohmann::json next = getNextElement();
- if (next.is_null())
- {
- return data::Descriptor::eUnknown;
- }
-
- std::string type_as_str = next.at(io::Data::READER_WRITER_TYPE_SLUG);
- data::Descriptor desc = data::STRING_TO_DESCRIPTOR(type_as_str);
- return desc;
- }
-
- nlohmann::json getNextElement() const override
- {
- if (!hasNextElement())
- {
- return nlohmann::json();
- }
-
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- nlohmann::json ret = element.at(getCurrentKey());
- return ret;
- }
- case data::Descriptor::eList:
- {
- nlohmann::json ret = element.at(io::Data::READER_WRITER_VALUE_SLUG).at(currentIndex);
- return ret;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONReaderToken", "getNextElement", "Could not resove a type of a json. Allowed are only container types due to performance", descriptor);
- }
- }
-
- virtual bool hasNextElement() const override
- {
- switch (descriptor)
- {
- case data::Descriptor::eDict:
- {
- nlohmann::json ret = element.at(getCurrentKey());
- return !ret.is_null();
- }
- case data::Descriptor::eList:
- {
- auto size = element.at(io::Data::READER_WRITER_VALUE_SLUG).size();
- return size >= currentIndex;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONReaderToken", "hasData", "Could not resove a type of a json. Allowed are only container types due to performance", descriptor);
- }
- }
-
- private:
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.cpp
deleted file mode 100644
index e6646349096ddc8f312a0a03b8affd4a0c767f43..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "Visitor.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Resolver.h>
-
-
-
-namespace armarx::aron::dataIO
-{
-
- void Visitor::VisitAndSetup(WriterInterface& writer, const datanavigator::NavigatorPtr& aron)
- {
- if (!aron)
- {
- writer.writeNull();
- return;
- }
-
- VisitAndSetup(writer, aron->toAronPtr());
- }
-
- void Visitor::VisitAndSetup(WriterInterface& writer, const data::AronDataPtr& aron)
- {
- if (!aron)
- {
- writer.writeNull();
- return;
- }
-
- data::Descriptor desc = Resolver::GetDescriptor(aron);
- switch (desc)
- {
- case data::Descriptor::eDict:
- {
- data::AronDictPtr casted = data::AronDictPtr::dynamicCast(aron);
- writer.writeStartDict();
- for (const auto& [key, value] : casted->elements)
- {
- //std::cout << "Visit writer for " << key << std::endl;
- writer.writeKey(key);
- Visitor::VisitAndSetup(writer, value);
- }
- writer.writeEndDict();
- break;
- }
- case data::Descriptor::eList:
- {
- data::AronListPtr casted = data::AronListPtr::dynamicCast(aron);
- writer.writeStartList();
- for (const auto& value : casted->elements)
- {
- Visitor::VisitAndSetup(writer, value);
- }
- writer.writeEndList();
- break;
- }
- case data::Descriptor::eNDArray:
- {
- data::AronNDArrayPtr casted = data::AronNDArrayPtr::dynamicCast(aron);
- writer.writeNDArray(casted->dimensions, casted->type, casted->data.data());
- break;
- }
- case data::Descriptor::eInt:
- {
- data::AronIntPtr casted = data::AronIntPtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- case data::Descriptor::eLong:
- {
- data::AronLongPtr casted = data::AronLongPtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- case data::Descriptor::eFloat:
- {
- data::AronFloatPtr casted = data::AronFloatPtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- case data::Descriptor::eDouble:
- {
- data::AronDoublePtr casted = data::AronDoublePtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- case data::Descriptor::eString:
- {
- data::AronStringPtr casted = data::AronStringPtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- case data::Descriptor::eBool:
- {
- data::AronBoolPtr casted = data::AronBoolPtr::dynamicCast(aron);
- writer.writePrimitive(casted->value);
- break;
- }
- default:
- {
- throw error::DescriptorNotValidException("LegacyAronDataWriter", "SetupWriterFromAronDataPtr", "Data-Type could not be resolved. The ice_id of the input was: " + aron->ice_id(), desc);
- }
- }
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.h b/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.h
deleted file mode 100644
index b6b00cbbc7d55ff95c3a1674af3dd7d6b9b28e29..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/visitor/Visitor.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/Writer.h>
-
-
-namespace armarx::aron::dataIO
-{
- class Visitor;
- typedef std::shared_ptr<Visitor> VisitorPtr;
-
- class Visitor
- {
- private:
- Visitor() = delete;
-
- public:
- static void VisitAndSetup(WriterInterface&, const datanavigator::NavigatorPtr&);
- static void VisitAndSetup(WriterInterface&, const data::AronDataPtr&);
-
- public:
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/WriterToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/WriterToken.h
deleted file mode 100644
index f91f6c0404fa5f1efaca3301b754165e98abebc8..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/WriterToken.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/io/Data.h>
-
-namespace armarx::aron::dataIO
-{
- template<typename ElementTypename>
- class WriterTokenInterface;
-
- template<typename ElementTypename>
- using WriterTokenPtr = std::shared_ptr<WriterTokenInterface<ElementTypename>>;
-
- template<typename ElementTypename>
- class WriterTokenInterface
- {
- public:
- using PointerType = WriterTokenInterface<ElementTypename>;
-
- // Interface
- virtual void addElement(const ElementTypename&) = 0;
-
- // General implementation
- void setCurrentKey(const std::string& s)
- {
- if (s.empty())
- {
- throw error::AronException("AronWriterToken", "setCurrentKey", "The passed key is empty.");
- }
- currentKey = s;
- }
-
- ElementTypename getElement() const
- {
- return element;
- }
-
- data::Descriptor getDescriptor() const
- {
- return descriptor;
- }
-
- std::string toAccessor() const
- {
- data::Descriptor desc = this->getDescriptor();
- switch (desc)
- {
- case data::Descriptor::eDict:
- return currentKey;
- case data::Descriptor::eList:
- return std::to_string(currentIndex);
- default:
- throw error::DescriptorNotValidException("NavigatorWriterToken", "toElementAccessor", "Could not resove a type of a navigator. Allowed are only containers.", desc);
- }
- }
-
- protected:
- // members
- data::Descriptor descriptor = data::Descriptor::eUnknown;
- ElementTypename element;
-
- // current index
- unsigned int currentIndex = 0;
-
- // current key
- std::string currentKey = "";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.cpp
deleted file mode 100644
index b1c25a788a0c1380ef2f8e0f4aa2d9f2acf967b6..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "NavigatorWriter.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-
-namespace armarx::aron::dataIO::writer
-{
-
- Path NavigatorWriter::generatePath()
- {
- Path path;
- if (!wroteInitialStartContainer)
- {
- wroteInitialStartContainer = true;
- }
- else
- {
- auto parent_token = stack.top();
- path = Path(parent_token->getElement()->getPath(), parent_token->toAccessor());
- }
- return path;
- }
-
- // Containers
- void NavigatorWriter::writeStartDict()
- {
- Path path = generatePath();
- auto data = std::make_shared<datanavigator::DictNavigator>(path);
- auto new_token = std::make_shared<NavigatorWriterToken>(data);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndDict()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NavigatorWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NavigatorWriter::writeStartList()
- {
- Path path = generatePath();
- auto data = std::make_shared<datanavigator::ListNavigator>(path);
- auto new_token = std::make_shared<NavigatorWriterToken>(data);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndList()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NavigatorWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- // Complex Types
- void NavigatorWriter::writeNDArray(const std::vector<int>& dims, const std::string& t, const unsigned char* data)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- datanavigator::NDArrayNavigatorPtr aron(new datanavigator::NDArrayNavigator(path));
- aron->setDimensions(dims);
- aron->setType(t);
- int size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
- aron->setData(static_cast<unsigned int>(size), data);
- token->addElement(aron);
- }
-
-
- // Primitive Types
- void NavigatorWriter::writePrimitive(const int x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::IntNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writePrimitive(const long x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::LongNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writePrimitive(const float x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::FloatNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writePrimitive(const double x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::DoubleNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writePrimitive(const std::string& x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::StringNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writePrimitive(const bool x)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto aron = std::make_shared<datanavigator::BoolNavigator>(path);
- aron->setValue(x);
- token->addElement(aron);
- }
-
- void NavigatorWriter::writeNull()
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- token->addElement(nullptr);
- }
-
- void NavigatorWriter::writeKey(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h
deleted file mode 100644
index 483883b85b9205adac25ac69fd738f0298895e87..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <stack>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/io/dataIO/Writer.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriterToken.h>
-
-namespace armarx::aron::dataIO::writer
-{
- class NavigatorWriter;
- typedef std::shared_ptr<NavigatorWriter> NavigatorWriterPtr;
-
- class NavigatorWriter :
- virtual public WriterInterface
- {
- public:
- NavigatorWriter() = default;
-
- virtual void writeStartDict() override;
- virtual void writeEndDict() override;
- virtual void writeStartList() override;
- virtual void writeEndList() override;
-
- virtual void writeNDArray(const std::vector<int>&, const std::string&, const unsigned char*) override;
-
- virtual void writePrimitive(const int) override;
- virtual void writePrimitive(const long) override;
- virtual void writePrimitive(const float) override;
- virtual void writePrimitive(const double) override;
- virtual void writePrimitive(const std::string&) override;
- virtual void writePrimitive(const bool) override;
-
- virtual void writeNull() override;
-
- virtual void writeKey(const std::string&) override;
-
- datanavigator::NavigatorPtr getResult() const
- {
- return lastRemovedToken->getElement();
- }
-
- private:
- Path generatePath();
-
- private:
- bool wroteInitialStartContainer = false;
- NavigatorWriterTokenPtr lastRemovedToken = nullptr;
- std::stack<NavigatorWriterTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriterToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriterToken.h
deleted file mode 100644
index c7de6070ec9688fcd39a5bd6d2b027c82de70224..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriterToken.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/WriterToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-namespace armarx::aron::dataIO::writer
-{
- class NavigatorWriterToken;
- typedef std::shared_ptr<NavigatorWriterToken> NavigatorWriterTokenPtr;
-
- class NavigatorWriterToken :
- virtual public WriterTokenInterface<datanavigator::NavigatorPtr>
- {
- public:
- using PointerType = NavigatorWriterTokenPtr;
-
- public:
- // constructor
- NavigatorWriterToken() = delete;
- NavigatorWriterToken(const datanavigator::NavigatorPtr& d)
- {
- ARMARX_CHECK_NOT_NULL(d);
-
- descriptor = d->getDescriptor();
- element = d;
- }
-
- // public member functions
- virtual void addElement(const datanavigator::NavigatorPtr& n) override
- {
- auto desc = this->getDescriptor();
- switch (desc)
- {
- case data::Descriptor::eDict:
- {
- datanavigator::DictNavigatorPtr casted = datanavigator::DictNavigator::DynamicCastAndCheck(element);
- casted->addElement(currentKey, n);
- break;
- }
- case data::Descriptor::eList:
- {
- datanavigator::ListNavigatorPtr casted = datanavigator::ListNavigator::DynamicCastAndCheck(element);
- casted->addElement(n);
- currentIndex++;
- break;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorWriterToken", "addElement", "Could not resove a type of a navigator. Allowed are only containers. The path was: " + element->pathToString(), desc);
- }
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
deleted file mode 100644
index b12b59774aa483a71dfbff040ad493abda841e79..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller (fabian dot peller at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include <numeric>
-
-#include "NlohmannJSONWriter.h"
-
-namespace armarx::aron::dataIO::writer
-{
-
- // Containers
- void NlohmannJSONWriter::writeStartDict()
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_DICT_TYPENAME_SLUG;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndDict()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeStartList()
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_LIST_TYPENAME_SLUG;
- data[io::Data::READER_WRITER_VALUE_SLUG] = nlohmann::json::array();
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndList()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- // Complex Types
- void NlohmannJSONWriter::writeNDArray(const std::vector<int>& dims, const std::string& t, const unsigned char* data) \
- {
- NlohmannJSONWriterTokenPtr token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_NDARRAY_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_NDARRAY_DIMENSIONS_SLUG] = dims;
- j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG] = t;
- int elements = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
- std::vector<unsigned char> d = std::vector<unsigned char>(elements);
- memcpy(d.data(), data, elements);
- j[io::Data::READER_WRITER_NDARRAY_DATA_SLUG] = d;
- token->addElement(j);
- }
-
- // Primitive
- void NlohmannJSONWriter::writePrimitive(const int x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_INT_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePrimitive(const long x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_LONG_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePrimitive(const float x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_FLOAT_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePrimitive(const double x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_DOUBLE_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePrimitive(const std::string& x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_STRING_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePrimitive(const bool x)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_BOOL_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_VALUE_SLUG] = x;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeNull()
- {
- auto token = stack.top();
- token->addElement(nullptr);
- }
-
- void NlohmannJSONWriter::writeKey(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h
deleted file mode 100644
index 44bf3c002101982f4e1f8af86e34838798bcd320..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD / STL
-#include <memory>
-#include <stack>
-#include <sstream>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/dataIO/Writer.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h>
-
-namespace armarx::aron::dataIO::writer
-{
- class NlohmannJSONWriter;
- typedef std::shared_ptr<NlohmannJSONWriter> NlohmannJSONWriterPtr;
-
- class NlohmannJSONWriter :
- virtual public WriterInterface
- {
- public:
- NlohmannJSONWriter() = default;
-
- virtual void writeStartDict() override;
- virtual void writeEndDict() override;
- virtual void writeStartList() override;
- virtual void writeEndList() override;
-
- virtual void writeNDArray(const std::vector<int>&, const std::string&, const unsigned char*) override;
-
- virtual void writePrimitive(const int) override;
- virtual void writePrimitive(const long) override;
- virtual void writePrimitive(const float) override;
- virtual void writePrimitive(const double) override;
- virtual void writePrimitive(const std::string&) override;
- virtual void writePrimitive(const bool) override;
-
- virtual void writeNull() override;
-
- virtual void writeKey(const std::string&) override;
-
- nlohmann::json getResult() const
- {
- return lastRemovedToken->getElement();
- }
-
- private:
- bool wroteInitialStartContainer = false;
- NlohmannJSONWriterTokenPtr lastRemovedToken = nullptr;
- std::stack<NlohmannJSONWriterTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h b/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
deleted file mode 100644
index ef8ded6b28d1b9ca65bfdf9a3470e39157030390..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/WriterToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-namespace armarx::aron::dataIO::writer
-{
- class NlohmannJSONWriterToken;
- typedef std::shared_ptr<NlohmannJSONWriterToken> NlohmannJSONWriterTokenPtr;
-
- class NlohmannJSONWriterToken :
- virtual public WriterTokenInterface<nlohmann::json>
- {
- public:
- using PointerType = NlohmannJSONWriterTokenPtr;
-
- public:
- // constructor
- NlohmannJSONWriterToken() = delete;
- NlohmannJSONWriterToken(const nlohmann::json& d)
- {
- descriptor = data::STRING_TO_DESCRIPTOR(d[io::Data::READER_WRITER_TYPE_SLUG]);
- element = d;
- }
-
- // public member functions
- virtual void addElement(const nlohmann::json& n) override
- {
- auto desc = this->getDescriptor();
- switch (desc)
- {
- case data::Descriptor::eDict:
- {
- element[currentKey] = n;
- break;
- }
- case data::Descriptor::eList:
- {
- element[io::Data::READER_WRITER_VALUE_SLUG].push_back(n);
- currentIndex++;
- break;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONWriterToken", "addElement", "Could not resove a type of a token. Allowed are only containers.", desc);
- }
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/Reader.h b/source/RobotAPI/libraries/aron/core/io/typeIO/Reader.h
deleted file mode 100644
index 6a070543e33b69691f381da73283634bb2308d1a..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/Reader.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-
-namespace armarx::aron::typeIO
-{
- class ReaderInterface;
- typedef std::shared_ptr<ReaderInterface> ReaderInterfacePtr;
-
- class ReaderInterface
- {
- public:
- struct ReadStartObjectReturnType
- {
- std::string name;
- unsigned int elements;
- type::Maybe maybe;
- };
- virtual ReadStartObjectReturnType readStartObject() = 0;
- virtual bool readEndObject() = 0;
-
- struct ReadStartListReturnType
- {
- unsigned int elements;
- type::Maybe maybe;
- };
- virtual ReadStartListReturnType readStartList() = 0;
- virtual bool readEndList() = 0;
-
- struct ReadStartDictReturnType
- {
- unsigned int elements;
- type::Maybe maybe;
- };
- virtual ReadStartDictReturnType readStartDict() = 0;
- virtual bool readEndDict() = 0;
-
- struct ReadStartTupleReturnType
- {
- unsigned int elements;
- type::Maybe maybe;
- };
- virtual ReadStartTupleReturnType readStartTuple() = 0;
- virtual bool readEndTuple() = 0;
-
- struct ReadStartPairReturnType
- {
- unsigned int elements;
- type::Maybe maybe;
- };
- virtual ReadStartPairReturnType readStartPair() = 0;
- virtual bool readEndPair() = 0;
-
- struct ReadEigenMatrixReturnType
- {
- unsigned int rows;
- unsigned int cols;
- std::string type;
- type::Maybe maybe;
- };
- virtual ReadEigenMatrixReturnType readEigenMatrix() = 0;
-
- struct ReadEigenQuaternionReturnType
- {
- std::string type;
- type::Maybe maybe;
- };
- virtual ReadEigenQuaternionReturnType readEigenQuaternion() = 0;
-
- struct ReadIVTCbyteImageReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadIVTCbyteImageReturnType readIVTCByteImage() = 0;
-
- struct ReadOpenCVMatReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadOpenCVMatReturnType readOpenCVMat() = 0;
-
- struct ReadPCLPointCloudReturnType
- {
- std::string type;
- type::Maybe maybe;
- };
- virtual ReadPCLPointCloudReturnType readPCLPointCloud() = 0;
-
- struct ReadPositionReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadPositionReturnType readPosition() = 0;
-
- struct ReadOrientationReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadOrientationReturnType readOrientation() = 0;
-
- struct ReadPoseReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadPoseReturnType readPose() = 0;
-
- struct ReadPrimitiveReturnType
- {
- type::Maybe maybe;
- };
- virtual ReadPrimitiveReturnType readInt() = 0;
- virtual ReadPrimitiveReturnType readLong() = 0;
- virtual ReadPrimitiveReturnType readFloat() = 0;
- virtual ReadPrimitiveReturnType readDouble() = 0;
- virtual ReadPrimitiveReturnType readString() = 0;
- virtual ReadPrimitiveReturnType readBool() = 0;
- virtual ReadPrimitiveReturnType readTime() = 0;
-
- virtual std::string readKey() = 0;
- virtual void loadMember(const std::string&) = 0;
-
- // Helper functions
- virtual type::Descriptor getTypeOfNext() const = 0;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/Writer.h b/source/RobotAPI/libraries/aron/core/io/typeIO/Writer.h
deleted file mode 100644
index 0790dacbc1e0a83e497253fc9e4ee6d17c2da9c2..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/Writer.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/Config.h>
-
-
-namespace armarx::aron::typeIO
-{
- class WriterInterface;
- typedef std::shared_ptr<WriterInterface> WriterInterfacePtr;
-
- class WriterInterface
- {
- public:
- struct WriteStartObjectInput
- {
- std::string name;
- type::Maybe maybe;
- };
- virtual void writeStartObject(const WriteStartObjectInput&) = 0;
- virtual void writeEndObject() = 0;
-
- struct WriteStartListInput
- {
- type::Maybe maybe;
- };
- virtual void writeStartList(const WriteStartListInput&) = 0;
- virtual void writeEndList() = 0;
-
- struct WriteStartDictInput
- {
- type::Maybe maybe;
- };
- virtual void writeStartDict(const WriteStartDictInput&) = 0;
- virtual void writeEndDict() = 0;
-
- struct WriteStartTupleInput
- {
- type::Maybe maybe;
- };
- virtual void writeStartTuple(const WriteStartTupleInput&) = 0;
- virtual void writeEndTuple() = 0;
-
- struct WriteStartPairInput
- {
- type::Maybe maybe;
- };
- virtual void writeStartPair(const WriteStartPairInput&) = 0;
- virtual void writeEndPair() = 0;
-
- struct WriteEigenMatrixInput
- {
- unsigned int rows;
- unsigned int cols;
- std::string type;
- type::Maybe maybe;
- };
- virtual void writeEigenMatrix(const WriteEigenMatrixInput&) = 0;
-
- struct WriteEigenQuaternionInput
- {
- std::string type;
- type::Maybe maybe;
- };
- virtual void writeEigenQuaternion(const WriteEigenQuaternionInput&) = 0;
-
- struct WriteImageInput
- {
- std::string pixelType;
- type::Maybe maybe;
- };
- virtual void writeImage(const WriteImageInput&) = 0;
-
- struct WriteIVTCByteImageInput
- {
- type::Maybe maybe;
- };
- virtual void writeIVTCByteImage(const WriteIVTCByteImageInput&) = 0;
-
- struct WriteOpenCVMatInput
- {
- type::Maybe maybe;
- };
- virtual void writeOpenCVMat(const WriteOpenCVMatInput&) = 0;
-
- struct WritePCLPointCloudInput
- {
- std::string type;
- type::Maybe maybe;
- };
- virtual void writePCLPointCloud(const WritePCLPointCloudInput&) = 0;
-
- struct WritePositionInput
- {
- type::Maybe maybe;
- };
- virtual void writePosition(const WritePositionInput&) = 0;
-
- struct WriteOrientationInput
- {
- type::Maybe maybe;
- };
- virtual void writeOrientation(const WriteOrientationInput&) = 0;
-
- struct WritePoseInput
- {
- type::Maybe maybe;
- };
- virtual void writePose(const WritePoseInput&) = 0;
-
- struct WritePrimitiveInput
- {
- type::Maybe maybe;
- };
- virtual void writeInt(const WritePrimitiveInput&) = 0;
- virtual void writeLong(const WritePrimitiveInput&) = 0;
- virtual void writeFloat(const WritePrimitiveInput&) = 0;
- virtual void writeDouble(const WritePrimitiveInput&) = 0;
- virtual void writeString(const WritePrimitiveInput&) = 0;
- virtual void writeBool(const WritePrimitiveInput&) = 0;
- virtual void writeTime(const WritePrimitiveInput&) = 0;
-
- virtual void writeKey(const std::string&) = 0;
- virtual void writeExtends() = 0;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.cpp
deleted file mode 100644
index f5df053b92c714a3285cc743cb5ebabd49421f87..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "Converter.h"
-
-namespace armarx::aron::typeIO
-{
- void Converter::ReadAndConvert(ReaderInterface& reader, WriterInterface& writer)
- {
- type::Descriptor desc = reader.getTypeOfNext();
- switch (desc)
- {
- case type::Descriptor::eObject:
- {
- const auto readStartObject = reader.readStartObject();
- writer.writeStartObject({readStartObject.name, readStartObject.maybe});
-
- for (unsigned int i = 0; i < readStartObject.elements; ++i)
- {
- std::string key = reader.readKey();
- writer.writeKey(key);
- Converter::ReadAndConvert(reader, writer);
- }
-
- writer.writeEndObject();
- reader.readEndObject();
- break;
- }
- case type::Descriptor::eDict:
- {
- const auto readStartDict = reader.readStartDict();
- writer.writeStartDict({readStartDict.maybe});
-
- Converter::ReadAndConvert(reader, writer);
-
- writer.writeEndDict();
- reader.readEndDict();
- break;
- }
- case type::Descriptor::eTuple:
- {
- const auto readStartTuple = reader.readStartTuple();
- writer.writeStartTuple({readStartTuple.maybe});
-
- for (unsigned int i = 0; i < readStartTuple.elements; ++i)
- {
- Converter::ReadAndConvert(reader, writer);
- }
-
- writer.writeEndTuple();
- reader.readEndTuple();
- break;
- }
- case type::Descriptor::eList:
- {
- const auto readStartList = reader.readStartList();
- writer.writeStartList({readStartList.maybe});
-
- Converter::ReadAndConvert(reader, writer);
-
- writer.writeEndList();
- reader.readEndList();
- break;
- }
- case type::Descriptor::eEigenMatrix:
- {
- const auto readEigenMatrix = reader.readEigenMatrix();
- writer.writeEigenMatrix({readEigenMatrix.rows, readEigenMatrix.cols, readEigenMatrix.type, readEigenMatrix.maybe});
- break;
- }
- case type::Descriptor::eEigenQuaternion:
- {
- const auto readEigenQuaternion = reader.readEigenQuaternion();
- writer.writeEigenQuaternion({readEigenQuaternion.type, readEigenQuaternion.maybe});
- break;
- }
- case type::Descriptor::eIVTCByteImage:
- {
- const auto readIVTCByteImage = reader.readIVTCByteImage();
- writer.writeIVTCByteImage({readIVTCByteImage.maybe});
- break;
- }
- case type::Descriptor::eOpenCVMat:
- {
- const auto readOpenCVMat = reader.readOpenCVMat();
- writer.writeOpenCVMat({readOpenCVMat.maybe});
- break;
- }
- case type::Descriptor::ePCLPointCloud:
- {
- const auto readPCLPointCloud = reader.readPCLPointCloud();
- writer.writePCLPointCloud({readPCLPointCloud.type, readPCLPointCloud.maybe});
- break;
- }
- case type::Descriptor::ePosition:
- {
- const auto readPosition = reader.readPosition();
- writer.writePosition({readPosition.maybe});
- break;
- }
- case type::Descriptor::eOrientation:
- {
- const auto readOrientation = reader.readOrientation();
- writer.writeOrientation({readOrientation.maybe});
- break;
- }
- case type::Descriptor::ePose:
- {
- const auto readPose = reader.readPose();
- writer.writePose({readPose.maybe});
- break;
- }
- case type::Descriptor::eInt:
- {
- const auto readInt = reader.readInt();
- writer.writeInt({readInt.maybe});
- break;
- }
- case type::Descriptor::eLong:
- {
- const auto readLong = reader.readLong();
- writer.writeLong({readLong.maybe});
- break;
- }
- case type::Descriptor::eFloat:
- {
- const auto readFloat = reader.readFloat();
- writer.writeFloat({readFloat.maybe});
- break;
- }
- case type::Descriptor::eDouble:
- {
- const auto readDouble = reader.readDouble();
- writer.writeDouble({readDouble.maybe});
- break;
- }
- case type::Descriptor::eString:
- {
- const auto readString = reader.readString();
- writer.writeString({readString.maybe});
- break;
- }
- case type::Descriptor::eBool:
- {
- const auto readBool = reader.readBool();
- writer.writeBool({readBool.maybe});
- break;
- }
- case type::Descriptor::eTime:
- {
- const auto readTime = reader.readTime();
- writer.writeTime({readTime.maybe});
- break;
- }
- default:
- {
- throw error::DescriptorNotValidException("LegacyAronTypeReader", "ConvertFromReader", "Type could not be resolved", desc);
- }
- }
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.h b/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.h
deleted file mode 100644
index 8ef1007efb1d06ac2b0360ccc8008f7fdfa634d2..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/converter/Converter.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// BaseClass
-
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/Reader.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/Writer.h>
-
-
-namespace armarx::aron::typeIO
-{
- class Converter;
- typedef std::shared_ptr<Converter> AronTypeConverterPtr;
-
- class Converter
- {
- private:
- Converter() = delete;
-
- public:
- static void ReadAndConvert(ReaderInterface&, WriterInterface&);
-
- public:
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/ReaderToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/ReaderToken.h
deleted file mode 100644
index 17b364ff4874a397820cf3143fb180cf21cd8275..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/ReaderToken.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-#include <vector>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/io/Data.h>
-
-namespace armarx::aron::typeIO
-{
- template<typename ElementTypename>
- class ReaderTokenInterface;
-
- template<typename ElementTypename>
- using ReaderTokenInterfacePtr = std::shared_ptr<ReaderTokenInterface<ElementTypename>>;
-
- template<typename ElementTypename>
- class ReaderTokenInterface
- {
- public:
- using PointerType = ReaderTokenInterfacePtr<ElementTypename>;
-
- public:
- // Interface
- virtual type::Descriptor getTypeOfNext() const = 0;
- virtual ElementTypename getNextElement() const = 0;
-
- // General implementation
- std::string getElementName() const
- {
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- case type::Descriptor::eIntEnum:
- {
- return elementName;
- }
- default:
- throw error::DescriptorNotValidException("ReaderTokenInterface", "getElementName", "Could not get object nme of a non-object or non-enum token", descriptor);
- }
- }
-
- type::Descriptor getDescriptor() const
- {
- return descriptor;
- }
-
- unsigned int getElementChildrenSize() const
- {
- return childrenSize;
- }
-
- bool finishedElement() const
- {
- return currentIndex >= getElementChildrenSize();
- }
-
- std::string getCurrentKey() const
- {
- assertIndexInBounds();
-
- // ugly workaround
- if (this->currentKey == "") // probably in a dict where the caller does not know which keys are there
- {
- if (this->allMemberNames.size() == 0)
- {
- throw error::AronException("typeIO::ReaderTokenInterface", "getCurrentKey", "The currentKey is not set and the list of all keys is empty!");
- }
- return this->allMemberNames[this->currentIndex];
- }
- return this->currentKey;
- }
-
- void setCurrentKey(const std::string& s)
- {
- currentKey = s;
- }
-
- void assertType(type::Descriptor t) const
- {
- if (getDescriptor() != t)
- {
- throw error::DescriptorNotValidException("typeIO::ReaderTokenInterface", "assertType", "The type was not equal.", t);
- }
- }
-
- void assertIndexInBounds() const
- {
- if (this->currentIndex >= getElementChildrenSize())
- {
- throw error::SizeNotValidException("typeIO::ReaderTokenInterface", "assertIndexInBounds", "Index out of bounds.", this->currentIndex, getElementChildrenSize());
- }
- }
-
- ElementTypename getNextElementAndIncreaseCnt()
- {
- ElementTypename next = getNextElement();
- this->currentIndex++;
- return next;
- }
-
- protected:
- // members
- type::Descriptor descriptor = type::Descriptor::eUnknown;
- ElementTypename element;
- std::string elementName = "";
-
- unsigned int childrenSize = 0;
- unsigned int currentIndex = 0;
-
- std::string currentKey = "";
- std::vector<std::string> allMemberNames = {};
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.cpp
deleted file mode 100644
index d52367bce8274a85c195ee213b5a033971781c3c..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "NavigatorReader.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-
-namespace armarx::aron::typeIO::reader
-{
- NavigatorReader::NavigatorReader(const typenavigator::NavigatorPtr& n) :
- input(n)
- {
- }
-
- NavigatorReader::NavigatorReader(const type::AronTypePtr& n) :
- input(typenavigator::Navigator::FromAronType(n))
- {
- }
-
- typenavigator::NavigatorPtr NavigatorReader::getNextAndIncrease()
- {
- if (!readInitialStart)
- {
- readInitialStart = true;
- return input;
- }
- NavigatorReaderTokenPtr lastToken = stack.top();
- return lastToken->getNextElementAndIncreaseCnt();
- }
-
- ReaderInterface::ReadStartObjectReturnType NavigatorReader::readStartObject()
- {
- auto current_nav = getNextAndIncrease();
- auto current_nav_casted = typenavigator::ObjectNavigator::DynamicCastAndCheck(current_nav);
- auto newToken = std::make_shared<NavigatorReaderToken>(type::Descriptor::eObject, current_nav_casted);
- stack.push(newToken);
- return {newToken->getElementName(), newToken->getElementChildrenSize(), current_nav_casted->getMaybe()};
- }
-
- bool NavigatorReader::readEndObject()
- {
- auto token = stack.top();
- token->assertType(type::Descriptor::eObject);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartDictReturnType NavigatorReader::readStartDict()
- {
- auto current_nav = getNextAndIncrease();
- auto current_nav_casted = typenavigator::DictNavigator::DynamicCastAndCheck(current_nav);
- auto newToken = std::make_shared<NavigatorReaderToken>(type::Descriptor::eDict, current_nav_casted);
- stack.push(newToken);
- return {newToken->getElementChildrenSize(), current_nav_casted->getMaybe()};
- }
-
- bool NavigatorReader::readEndDict()
- {
- auto token = stack.top();
- token->assertType(type::Descriptor::eDict);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartListReturnType NavigatorReader::readStartList()
- {
- auto current_nav = getNextAndIncrease();
- auto current_nav_casted = typenavigator::ListNavigator::DynamicCastAndCheck(current_nav);
- auto newToken = std::make_shared<NavigatorReaderToken>(type::Descriptor::eList, current_nav_casted);
- stack.push(newToken);
- return {newToken->getElementChildrenSize(), current_nav_casted->getMaybe()};
- }
-
- bool NavigatorReader::readEndList()
- {
- auto token = stack.top();
- token->assertType(type::Descriptor::eList);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartTupleReturnType NavigatorReader::readStartTuple()
- {
- auto current_nav = getNextAndIncrease();
- auto current_nav_casted = typenavigator::TupleNavigator::DynamicCastAndCheck(current_nav);
- auto newToken = std::make_shared<NavigatorReaderToken>(type::Descriptor::eTuple, current_nav_casted);
- stack.push(newToken);
- return {newToken->getElementChildrenSize(), current_nav_casted->getMaybe()};
- }
-
- bool NavigatorReader::readEndTuple()
- {
- auto token = stack.top();
- token->assertType(type::Descriptor::eTuple);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartPairReturnType NavigatorReader::readStartPair()
- {
- auto current_nav = getNextAndIncrease();
- auto current_nav_casted = typenavigator::PairNavigator::DynamicCastAndCheck(current_nav);
- auto newToken = std::make_shared<NavigatorReaderToken>(type::Descriptor::ePair, current_nav_casted);
- stack.push(newToken);
- return {newToken->getElementChildrenSize(), current_nav_casted->getMaybe()};
- }
-
- bool NavigatorReader::readEndPair()
- {
- auto token = stack.top();
- token->assertType(type::Descriptor::ePair);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadEigenMatrixReturnType NavigatorReader::readEigenMatrix()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::EigenMatrixNavigator::DynamicCastAndCheck(nav);
- return {casted->getRows(), casted->getCols(), casted->getTypename(), casted->getMaybe()};
- }
-
- ReaderInterface::ReadEigenQuaternionReturnType NavigatorReader::readEigenQuaternion()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::EigenMatrixNavigator::DynamicCastAndCheck(nav);
- return {casted->getTypename(), casted->getMaybe()};
- }
-
- ReaderInterface::ReadIVTCbyteImageReturnType NavigatorReader::readIVTCByteImage()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::IVTCByteImageNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadOpenCVMatReturnType NavigatorReader::readOpenCVMat()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::OpenCVMatNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPCLPointCloudReturnType NavigatorReader::readPCLPointCloud()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::PCLPointCloudNavigator::DynamicCastAndCheck(nav);
- return {casted->getTypename(), casted->getMaybe()};
- }
-
- ReaderInterface::ReadPositionReturnType NavigatorReader::readPosition()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::PositionNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadOrientationReturnType NavigatorReader::readOrientation()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::OrientationNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPoseReturnType NavigatorReader::readPose()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::PoseNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- // Read primitives
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readInt()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::IntNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readFloat()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::FloatNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readLong()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::LongNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readDouble()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::DoubleNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readString()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::StringNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readBool()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::BoolNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NavigatorReader::readTime()
- {
- auto nav = getNextAndIncrease();
- auto casted = typenavigator::TimeNavigator::DynamicCastAndCheck(nav);
- return {casted->getMaybe()};
- }
-
- std::string NavigatorReader::readKey()
- {
- auto token = stack.top();
- return token->getCurrentKey();
- }
-
- void NavigatorReader::loadMember(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- // Helper functions
- type::Descriptor NavigatorReader::getTypeOfNext() const
- {
- auto token = stack.top();
- return token->getTypeOfNext();
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.h b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.h
deleted file mode 100644
index d85113eb9349b3f7ef65facb324a71f76a04419b..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <stack>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/io/typeIO/Reader.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReaderToken.h>
-
-
-namespace armarx::aron::typeIO::reader
-{
- class NavigatorReader;
- typedef std::shared_ptr<NavigatorReader> NavigatorReaderPtr;
-
- class NavigatorReader :
- virtual public ReaderInterface
- {
- public:
- using PointerType = NavigatorReaderPtr;
-
- public:
- // constructors
- NavigatorReader() = delete;
- NavigatorReader(const typenavigator::NavigatorPtr& n);
- NavigatorReader(const type::AronTypePtr& n);
-
- virtual ReadStartObjectReturnType readStartObject() override;
- virtual bool readEndObject() override;
- virtual ReadStartListReturnType readStartList() override;
- virtual bool readEndList() override;
- virtual ReadStartDictReturnType readStartDict() override;
- virtual bool readEndDict() override;
- virtual ReadStartTupleReturnType readStartTuple() override;
- virtual bool readEndTuple() override;
- virtual ReadStartPairReturnType readStartPair() override;
- virtual bool readEndPair() override;
-
- virtual ReadEigenMatrixReturnType readEigenMatrix() override;
- virtual ReadEigenQuaternionReturnType readEigenQuaternion() override;
- virtual ReadIVTCbyteImageReturnType readIVTCByteImage() override;
- virtual ReadOpenCVMatReturnType readOpenCVMat() override;
- virtual ReadPCLPointCloudReturnType readPCLPointCloud() override;
- virtual ReadPositionReturnType readPosition() override;
- virtual ReadOrientationReturnType readOrientation() override;
- virtual ReadPoseReturnType readPose() override;
-
- virtual ReadPrimitiveReturnType readInt() override;
- virtual ReadPrimitiveReturnType readLong() override;
- virtual ReadPrimitiveReturnType readFloat() override;
- virtual ReadPrimitiveReturnType readDouble() override;
- virtual ReadPrimitiveReturnType readString() override;
- virtual ReadPrimitiveReturnType readBool() override;
- virtual ReadPrimitiveReturnType readTime() override;
-
- virtual std::string readKey() override;
- virtual void loadMember(const std::string&) override;
-
- // Helper functions
- virtual type::Descriptor getTypeOfNext() const override;
-
- private:
- typenavigator::NavigatorPtr getNextAndIncrease();
-
- private:
- typenavigator::NavigatorPtr input;
- bool readInitialStart = false;
- std::stack<NavigatorReaderTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReaderToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReaderToken.h
deleted file mode 100644
index 9c8425ce589d6585bb6a460ea4774b76960707e7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReaderToken.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/ReaderToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx::aron::typeIO::reader
-{
- class NavigatorReaderToken;
- typedef std::shared_ptr<NavigatorReaderToken> NavigatorReaderTokenPtr;
-
- class NavigatorReaderToken :
- virtual public ReaderTokenInterface<typenavigator::NavigatorPtr>
- {
- public:
- using PointerType = NavigatorReaderTokenPtr;
-
- public:
- // constructors
- NavigatorReaderToken() = delete;
- NavigatorReaderToken(const type::Descriptor desc, const typenavigator::NavigatorPtr& type)
- {
- descriptor = desc;
- element = type;
-
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- {
- for (const auto& [key, _] : typenavigator::ObjectNavigator::DynamicCastAndCheck(element)->getMemberTypes())
- {
- allMemberNames.push_back(key);
- }
- childrenSize = type->childrenSize();
- break;
- }
- case type::Descriptor::eDict:
- {
- typenavigator::DictNavigator::DynamicCastAndCheck(element);
- childrenSize = 1;
- break;
- }
- case type::Descriptor::eTuple:
- {
- typenavigator::TupleNavigator::DynamicCastAndCheck(element);
- childrenSize = type->childrenSize();
- break;
- }
- case type::Descriptor::eList:
- {
- typenavigator::ListNavigator::DynamicCastAndCheck(element);
- childrenSize = 1;
- break;
- }
- case type::Descriptor::ePair:
- {
- typenavigator::PairNavigator::DynamicCastAndCheck(element);
- childrenSize = 2;
- break;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorReaderToken", "NavigatorReaderToken", "Received an invalid instance for a reader token.", desc);
- }
- }
-
- type::Descriptor getTypeOfNext() const override
- {
- const typenavigator::NavigatorPtr next = getNextElement();
- return next->getDescriptor();
- }
-
- typenavigator::NavigatorPtr getNextElement() const override
- {
- assertIndexInBounds();
-
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- {
- typenavigator::ObjectNavigatorPtr casted = typenavigator::ObjectNavigator::DynamicCastAndCheck(element);
- return casted->getMemberType(getCurrentKey());
- }
- case type::Descriptor::eDict:
- {
- typenavigator::DictNavigatorPtr casted = typenavigator::DictNavigator::DynamicCastAndCheck(element);
- return casted->getAcceptedType();
- }
- case type::Descriptor::eTuple:
- {
- typenavigator::TupleNavigatorPtr casted = typenavigator::TupleNavigator::DynamicCastAndCheck(element);
- return casted->getAcceptedType(currentIndex);
- }
- case type::Descriptor::eList:
- {
- typenavigator::ListNavigatorPtr casted = typenavigator::ListNavigator::DynamicCastAndCheck(element);
- return casted->getAcceptedType();
- }
- case type::Descriptor::ePair:
- {
- typenavigator::PairNavigatorPtr casted = typenavigator::PairNavigator::DynamicCastAndCheck(element);
- if (currentIndex == 0)
- {
- return casted->getFirstAcceptedType();
- }
- return casted->getSecondAcceptedType();
- }
- default:
- throw error::DescriptorNotValidException("NavigatorReaderToken", "getNextElement", "Could not resove a type of a navigator. Allowed are only container types due to performance", descriptor);
- }
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
deleted file mode 100644
index dbb7ef1ceba56fbbc7e8a994b7414a3296eacb24..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Header
-#include "NlohmannJSONReader.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx::aron::typeIO::reader
-{
- NlohmannJSONReader::NlohmannJSONReader(const nlohmann::json& n) :
- input(n)
- {
- }
-
- NlohmannJSONReader::NlohmannJSONReader(const std::string& n) :
- input(nlohmann::json::parse(n))
- {
- }
-
- nlohmann::json NlohmannJSONReader::getNextAndIncrease()
- {
- if (!readInitialStart)
- {
- readInitialStart = true;
- return input;
- }
- NlohmannJSONReaderTokenPtr lastToken = stack.top();
- return lastToken->getNextElementAndIncreaseCnt();
- }
-
- ReaderInterface::ReadStartObjectReturnType NlohmannJSONReader::readStartObject()
- {
- nlohmann::json current_json = getNextAndIncrease();
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(type::Descriptor::eObject, current_json);
- stack.push(newToken);
- type::Maybe o = current_json[io::Data::READER_WRITER_MAYBE_SLUG];
- return {newToken->getElementName(), newToken->getElementChildrenSize(), o};
- }
-
- bool NlohmannJSONReader::readEndObject()
- {
- NlohmannJSONReaderTokenPtr token = stack.top();
- token->assertType(type::Descriptor::eObject);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartDictReturnType NlohmannJSONReader::readStartDict()
- {
- nlohmann::json current_json = getNextAndIncrease();
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(type::Descriptor::eDict, current_json);
- stack.push(newToken);
- type::Maybe o = current_json[io::Data::READER_WRITER_MAYBE_SLUG];
- return {newToken->getElementChildrenSize(), o};
- }
-
- bool NlohmannJSONReader::readEndDict()
- {
- NlohmannJSONReaderTokenPtr token = stack.top();
- token->assertType(type::Descriptor::eDict);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartListReturnType NlohmannJSONReader::readStartList()
- {
- nlohmann::json current_json = getNextAndIncrease();
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(type::Descriptor::eList, current_json);
- stack.push(newToken);
- type::Maybe o = current_json[io::Data::READER_WRITER_MAYBE_SLUG];
- return {newToken->getElementChildrenSize(), o};
- }
-
- bool NlohmannJSONReader::readEndList()
- {
- NlohmannJSONReaderTokenPtr token = stack.top();
- token->assertType(type::Descriptor::eList);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartTupleReturnType NlohmannJSONReader::readStartTuple()
- {
- nlohmann::json current_json = getNextAndIncrease();
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(type::Descriptor::eTuple, current_json);
- stack.push(newToken);
- type::Maybe o = current_json[io::Data::READER_WRITER_MAYBE_SLUG];
- return {newToken->getElementChildrenSize(), o};
- }
-
- bool NlohmannJSONReader::readEndTuple()
- {
- NlohmannJSONReaderTokenPtr token = stack.top();
- token->assertType(type::Descriptor::eTuple);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadStartPairReturnType NlohmannJSONReader::readStartPair()
- {
- nlohmann::json current_json = getNextAndIncrease();
- auto newToken = std::make_shared<NlohmannJSONReaderToken>(type::Descriptor::ePair, current_json);
- stack.push(newToken);
- type::Maybe o = current_json[io::Data::READER_WRITER_MAYBE_SLUG];
- return {newToken->getElementChildrenSize(), o};
- }
-
- bool NlohmannJSONReader::readEndPair()
- {
- NlohmannJSONReaderTokenPtr token = stack.top();
- token->assertType(type::Descriptor::ePair);
-
- if (token->finishedElement())
- {
- stack.pop();
- return true;
- }
- return false;
- }
-
- ReaderInterface::ReadEigenMatrixReturnType NlohmannJSONReader::readEigenMatrix()
- {
- nlohmann::json j = getNextAndIncrease();
- std::vector<unsigned int> dims = j[io::Data::READER_WRITER_NDARRAY_DIMENSIONS_SLUG];
- std::string type = j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG];
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {dims[0], dims[1], type, o};
- }
-
- ReaderInterface::ReadEigenQuaternionReturnType NlohmannJSONReader::readEigenQuaternion()
- {
- nlohmann::json j = getNextAndIncrease();
- std::string type = j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG];
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {type, o};
- }
-
- ReaderInterface::ReadIVTCbyteImageReturnType NlohmannJSONReader::readIVTCByteImage()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadOpenCVMatReturnType NlohmannJSONReader::readOpenCVMat()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPCLPointCloudReturnType NlohmannJSONReader::readPCLPointCloud()
- {
- nlohmann::json j = getNextAndIncrease();
- std::string type = j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG];
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {type, o};
- }
-
- ReaderInterface::ReadPositionReturnType NlohmannJSONReader::readPosition()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadOrientationReturnType NlohmannJSONReader::readOrientation()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPoseReturnType NlohmannJSONReader::readPose()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- // Read primitives
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readInt()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readLong()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readFloat()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readDouble()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readString()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readBool()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- ReaderInterface::ReadPrimitiveReturnType NlohmannJSONReader::readTime()
- {
- nlohmann::json j = getNextAndIncrease();
- type::Maybe o = j[io::Data::READER_WRITER_MAYBE_SLUG];
- return {o};
- }
-
- std::string NlohmannJSONReader::readKey()
- {
- auto token = stack.top();
- return token->getCurrentKey();
- }
-
- void NlohmannJSONReader::loadMember(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- // Helper functions
- type::Descriptor NlohmannJSONReader::getTypeOfNext() const
- {
- if (stack.empty())
- {
- return type::Descriptor::eObject;
- }
-
- auto token = stack.top();
- return token->getTypeOfNext();
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.h b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.h
deleted file mode 100644
index 78caf17db08697fd0e2f47113dd7142df9a6de8b..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <stack>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/io/typeIO/Reader.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h>
-
-namespace armarx::aron::typeIO::reader
-{
- class NlohmannJSONReader;
- typedef std::shared_ptr<NlohmannJSONReader> NlohmannJSONReaderPtr;
-
- class NlohmannJSONReader :
- virtual public ReaderInterface
- {
- public:
- using PointerType = NlohmannJSONReaderPtr;
-
- public:
- // constructors
- NlohmannJSONReader() = delete;
- NlohmannJSONReader(const nlohmann::json& n);
- NlohmannJSONReader(const std::string& n);
-
- virtual ReadStartObjectReturnType readStartObject() override;
- virtual bool readEndObject() override;
- virtual ReadStartListReturnType readStartList() override;
- virtual bool readEndList() override;
- virtual ReadStartDictReturnType readStartDict() override;
- virtual bool readEndDict() override;
- virtual ReadStartTupleReturnType readStartTuple() override;
- virtual bool readEndTuple() override;
- virtual ReadStartPairReturnType readStartPair() override;
- virtual bool readEndPair() override;
-
- virtual ReadEigenMatrixReturnType readEigenMatrix() override;
- virtual ReadEigenQuaternionReturnType readEigenQuaternion() override;
- virtual ReadIVTCbyteImageReturnType readIVTCByteImage() override;
- virtual ReadOpenCVMatReturnType readOpenCVMat() override;
- virtual ReadPCLPointCloudReturnType readPCLPointCloud() override;
- virtual ReadPositionReturnType readPosition() override;
- virtual ReadOrientationReturnType readOrientation() override;
- virtual ReadPoseReturnType readPose() override;
-
- virtual ReadPrimitiveReturnType readInt() override;
- virtual ReadPrimitiveReturnType readLong() override;
- virtual ReadPrimitiveReturnType readFloat() override;
- virtual ReadPrimitiveReturnType readDouble() override;
- virtual ReadPrimitiveReturnType readString() override;
- virtual ReadPrimitiveReturnType readBool() override;
- virtual ReadPrimitiveReturnType readTime() override;
-
- virtual std::string readKey() override;
- virtual void loadMember(const std::string&) override;
-
- // Helper functions
- virtual type::Descriptor getTypeOfNext() const override;
-
- private:
- nlohmann::json getNextAndIncrease();
-
- private:
- nlohmann::json input;
- bool readInitialStart = false;
- std::stack<NlohmannJSONReaderTokenPtr> stack;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
deleted file mode 100644
index d95638c1a2c3d3b1f4c6ebf835a454f8831ea924..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReaderToken.h
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/ReaderToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Resolver.h>
-
-namespace armarx::aron::typeIO::reader
-{
- class NlohmannJSONReaderToken;
- typedef std::shared_ptr<NlohmannJSONReaderToken> NlohmannJSONReaderTokenPtr;
-
- class NlohmannJSONReaderToken :
- virtual public ReaderTokenInterface<nlohmann::json>
- {
- public:
- using PointerType = NlohmannJSONReaderTokenPtr;
-
- public:
- // constructors
- NlohmannJSONReaderToken() = delete;
- NlohmannJSONReaderToken(const type::Descriptor desc, const nlohmann::json& type)
- {
- descriptor = desc;
- element = type;
-
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- {
- for (auto& [key, val] : type.get<nlohmann::json::object_t>())
- {
- if (key == io::Data::READER_WRITER_OBJECT_NAME_SLUG)
- {
- continue;
- }
-
- allMemberNames.push_back(key);
- }
- childrenSize = allMemberNames.size();
- elementName = element[io::Data::READER_WRITER_OBJECT_NAME_SLUG];
- break;
- }
- case type::Descriptor::eDict:
- {
- childrenSize = 1;
- break;
- }
- case type::Descriptor::eTuple:
- {
- childrenSize = element.size();
- break;
- }
- case type::Descriptor::eList:
- {
- childrenSize = 1;
- break;
- }
- case type::Descriptor::ePair:
- {
- childrenSize = 2;
- break;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONReaderToken", "NlohmannJSONReaderToken", "Received an invalid instance for a reader token.", desc);
- }
- }
-
- type::Descriptor getTypeOfNext() const override
- {
- const nlohmann::json next = getNextElement();
-
- if (next.is_object())
- {
- if (next.find(io::Data::READER_WRITER_DICT_ACCEPTED_TYPE_SLUG) != next.end())
- {
- return type::Descriptor::eDict;
- }
- if (next.find(io::Data::READER_WRITER_LIST_ACCEPTED_TYPE_SLUG) != next.end())
- {
- return type::Descriptor::eList;
- }
- if (next.find(io::Data::READER_WRITER_INT_ENUM_NAME_SLUG) != next.end())
- {
- return type::Descriptor::eIntEnum;
- }
- if (next.find(io::Data::READER_WRITER_NDARRAY_NAME_SLUG) != next.end())
- {
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "EigenMatrix")
- {
- return type::Descriptor::eEigenMatrix;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "EigenQuaternion")
- {
- return type::Descriptor::eEigenQuaternion;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "IVTCByteImage")
- {
- return type::Descriptor::eIVTCByteImage;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "OpenCVMat")
- {
- return type::Descriptor::eOpenCVMat;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "PCLPointCloud")
- {
- return type::Descriptor::ePCLPointCloud;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "Position")
- {
- return type::Descriptor::ePosition;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "Orientation")
- {
- return type::Descriptor::eOrientation;
- }
- if (next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] == "Pose")
- {
- return type::Descriptor::ePose;
- }
- throw error::AronException("NlohmannJSONReaderToken", "getTypeOfNextElement", "Could not determine the type of an nlohmann::json object. Found indicator of NDArray but could not resolve real type. Found JSON: " + next[io::Data::READER_WRITER_NDARRAY_NAME_SLUG].dump(2));
- }
- return type::Descriptor::eObject;
- }
- if (next.is_array())
- {
- return type::Descriptor::eTuple;
- }
- if (next.is_string())
- {
- if (next == io::Data::READER_WRITER_INT_TYPENAME_SLUG)
- {
- return type::Descriptor::eInt;
- }
- if (next == io::Data::READER_WRITER_LONG_TYPENAME_SLUG)
- {
- return type::Descriptor::eLong;
- }
- if (next == io::Data::READER_WRITER_FLOAT_TYPENAME_SLUG)
- {
- return type::Descriptor::eFloat;
- }
- if (next == io::Data::READER_WRITER_DOUBLE_TYPENAME_SLUG)
- {
- return type::Descriptor::eDouble;
- }
- if (next == io::Data::READER_WRITER_STRING_TYPENAME_SLUG)
- {
- return type::Descriptor::eString;
- }
- if (next == io::Data::READER_WRITER_BOOL_TYPENAME_SLUG)
- {
- return type::Descriptor::eBool;
- }
- if (next == io::Data::READER_WRITER_TIME_TYPENAME_SLUG)
- {
- return type::Descriptor::eTime;
- }
- }
- throw error::AronException("NlohmannJSONReaderToken", "getTypeOfNextElement", "Could not determine the type of an nlohmann::json object. Could not convert to type::Descriptor enum. Found JSON: " + next.dump(2));
- }
-
- nlohmann::json getNextElement() const override
- {
- assertIndexInBounds();
-
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- {
- return element[getCurrentKey()];
- }
- case type::Descriptor::eDict:
- {
- return element[io::Data::READER_WRITER_DICT_ACCEPTED_TYPE_SLUG];
- }
- case type::Descriptor::eTuple:
- {
- return element[currentIndex];
- }
- case type::Descriptor::eList:
- {
- return element[io::Data::READER_WRITER_LIST_ACCEPTED_TYPE_SLUG];
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONReaderToken", "getNextElement", "Could not resove a type of a navigator. Allowed are only container types due to performance", descriptor);
- }
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.cpp
deleted file mode 100644
index 0e87ee0e42888a5fac73884aa82ef89fe6216cd4..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-// STD/STL
-#include <memory>
-#include <numeric>
-
-// Simox
-#include <SimoxUtility/algorithm/vector.hpp>
-
-// Header
-#include "Visitor.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Resolver.h>
-
-
-
-namespace armarx::aron::typeIO
-{
-
- void Visitor::VisitAndSetup(WriterInterface& writer, const typenavigator::NavigatorPtr& aron)
- {
- VisitAndSetup(writer, aron->toAronPtr());
- }
-
- void Visitor::VisitAndSetup(WriterInterface& writer, const type::AronTypePtr& aron)
- {
- type::Descriptor desc = Resolver::GetDescriptor(aron);
- switch (desc)
- {
- case type::Descriptor::eObject:
- {
- auto casted = type::AronObjectPtr::dynamicCast(aron);
- writer.writeStartObject({casted->objectName, casted->maybe});
- for (const auto& [key, value] : casted->elementTypes)
- {
- writer.writeKey(key);
- Visitor::VisitAndSetup(writer, value);
- }
- writer.writeEndObject();
- break;
- }
- case type::Descriptor::eDict:
- {
- auto casted = type::AronDictPtr::dynamicCast(aron);
- writer.writeStartDict({casted->maybe});
- Visitor::VisitAndSetup(writer, casted->acceptedType);
- writer.writeEndDict();
- break;
- }
- case type::Descriptor::eTuple:
- {
- auto casted = type::AronTuplePtr::dynamicCast(aron);
- writer.writeStartTuple({casted->maybe});
- for (const auto& value : casted->elementTypes)
- {
- Visitor::VisitAndSetup(writer, value);
- }
- writer.writeEndTuple();
- break;
- }
- case type::Descriptor::eList:
- {
- auto casted = type::AronListPtr::dynamicCast(aron);
- writer.writeStartList({casted->maybe});
- Visitor::VisitAndSetup(writer, casted->acceptedType);
- writer.writeEndList();
- break;
- }
- case type::Descriptor::eEigenMatrix:
- {
- auto casted = type::AronEigenMatrixPtr::dynamicCast(aron);
- writer.writeEigenMatrix({(unsigned int) casted->rows, (unsigned int) casted->cols, casted->typeName, casted->maybe});
- break;
- }
- case type::Descriptor::eEigenQuaternion:
- {
- auto casted = type::AronEigenQuaternionPtr::dynamicCast(aron);
- writer.writeEigenQuaternion({casted->typeName, casted->maybe});
- break;
- }
- case type::Descriptor::eIVTCByteImage:
- {
- auto casted = type::AronIVTCByteImagePtr::dynamicCast(aron);
- writer.writeIVTCByteImage({casted->maybe});
- break;
- }
- case type::Descriptor::eOpenCVMat:
- {
- auto casted = type::AronOpenCVMatPtr::dynamicCast(aron);
- writer.writeOpenCVMat({casted->maybe});
- break;
- }
- case type::Descriptor::ePCLPointCloud:
- {
- auto casted = type::AronPCLPointCloudPtr::dynamicCast(aron);
- writer.writePCLPointCloud({casted->typeName, casted->maybe});
- break;
- }
- case type::Descriptor::ePosition:
- {
- auto casted = type::AronPositionPtr::dynamicCast(aron);
- writer.writePosition({casted->maybe});
- break;
- }
- case type::Descriptor::eOrientation:
- {
- auto casted = type::AronOrientationPtr::dynamicCast(aron);
- writer.writeOrientation({casted->maybe});
- break;
- }
- case type::Descriptor::ePose:
- {
- auto casted = type::AronPosePtr::dynamicCast(aron);
- writer.writePose({casted->maybe});
- break;
- }
- case type::Descriptor::eInt:
- {
- auto casted = type::AronIntPtr::dynamicCast(aron);
- writer.writeInt({casted->maybe});
- break;
- }
- case type::Descriptor::eLong:
- {
- auto casted = type::AronLongPtr::dynamicCast(aron);
- writer.writeLong({casted->maybe});
- break;
- }
- case type::Descriptor::eFloat:
- {
- auto casted = type::AronFloatPtr::dynamicCast(aron);
- writer.writeFloat({casted->maybe});
- break;
- }
- case type::Descriptor::eDouble:
- {
- auto casted = type::AronDoublePtr::dynamicCast(aron);
- writer.writeDouble({casted->maybe});
- break;
- }
- case type::Descriptor::eString:
- {
- auto casted = type::AronStringPtr::dynamicCast(aron);
- writer.writeString({casted->maybe});
- break;
- }
- case type::Descriptor::eBool:
- {
- auto casted = type::AronBoolPtr::dynamicCast(aron);
- writer.writeBool({casted->maybe});
- break;
- }
- case type::Descriptor::eTime:
- {
- auto casted = type::AronTimePtr::dynamicCast(aron);
- writer.writeTime({casted->maybe});
- break;
- }
- default:
- {
- throw error::DescriptorNotValidException("Visitor", "VisitAndSetup", "Type could not be resolved. The ice_id of the input was: " + aron->ice_id(), desc);
- }
- }
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.h b/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.h
deleted file mode 100644
index fc9ea5b879011b109b5831418feab0e373311aef..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/visitor/Visitor.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/Writer.h>
-
-
-namespace armarx::aron::typeIO
-{
- class Visitor;
- typedef std::shared_ptr<Visitor> VisitorPtr;
-
- class Visitor
- {
- private:
- Visitor() = delete;
-
- public:
- static void VisitAndSetup(WriterInterface&, const typenavigator::NavigatorPtr&);
- static void VisitAndSetup(WriterInterface&, const type::AronTypePtr&);
-
- public:
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/WriterToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/WriterToken.h
deleted file mode 100644
index 37be1d9cae29ffd46a84ab818fd3ac9f6967b705..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/WriterToken.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/io/Data.h>
-
-namespace armarx::aron::typeIO
-{
- template<typename ElementTypename>
- class WriterTokenInterface;
-
- template<typename ElementTypename>
- using WriterTokenInterfacePtr = std::shared_ptr<WriterTokenInterface<ElementTypename>>;
-
- template<typename ElementTypename>
- class WriterTokenInterface
- {
- public:
- using PointerType = WriterTokenInterfacePtr<ElementTypename>;
-
- // Interface
- virtual void addElement(const ElementTypename&) = 0;
- virtual void setName(const std::string&) = 0;
-
- // General implementation
- std::string toAccessor() const
- {
- type::Descriptor desc = this->getDescriptor();
- switch (desc)
- {
- case type::Descriptor::eDict:
- case type::Descriptor::eList:
- return "[ACCEPTED_TYPE]";
- case type::Descriptor::eObject:
- return this->currentKey;
- case type::Descriptor::eTuple:
- return std::to_string(this->currentIndex);
- default:
- throw error::DescriptorNotValidException("NavigatorWriterToken", "toElementAccessor", "Could not resove a type of a navigator. Allowed are only containers.", desc);
- }
- }
-
- void setCurrentKey(const std::string& s)
- {
- if (s.empty())
- {
- throw error::AronException("AronWriterToken", "setCurrentKey", "The passed key is empty.");
- }
- currentKey = s;
- }
-
- ElementTypename getElement() const
- {
- return element;
- }
-
- type::Descriptor getDescriptor() const
- {
- return descriptor;
- }
-
- protected:
- // members
- type::Descriptor descriptor = type::Descriptor::eUnknown;
- ElementTypename element;
-
- // current index
- unsigned int currentIndex = 0;
-
- // current key
- std::string currentKey = "";
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.cpp
deleted file mode 100644
index 96290019ed99cb9ee80b489d6668cdb54769e38d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#include "NavigatorWriter.h"
-
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-#include <memory>
-#include <numeric>
-
-
-namespace armarx::aron::typeIO::writer
-{
- // generate Path info
- Path NavigatorWriter::generatePath()
- {
- Path path;
- if (!wroteInitialStartObject)
- {
- wroteInitialStartObject = true;
- }
- else
- {
- auto current = stack.top();
- path = Path(current->getElement()->getPath(), current->toAccessor());
- }
- return path;
- }
-
- // interface
- void NavigatorWriter::writeStartObject(const WriteStartObjectInput& o)
- {
- Path path = generatePath();
- auto type = std::make_shared<typenavigator::ObjectNavigator>(path);
- type->setObjectName(o.name);
- type->setMaybe(o.maybe);
- auto new_token = std::make_shared<NavigatorWriterToken>(type->getDescriptor(), type);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndObject()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NavigatorWriter::writeStartDict(const WriteStartDictInput& o)
- {
- Path path = generatePath();
- auto type = std::make_shared<typenavigator::DictNavigator>(path);
- type->setMaybe(o.maybe);
- auto new_token = std::make_shared<NavigatorWriterToken>(type->getDescriptor(), type);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndDict()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NavigatorWriter::writeStartList(const WriteStartListInput& o)
- {
- Path path = generatePath();
- auto type = std::make_shared<typenavigator::ListNavigator>(path);
- type->setMaybe(o.maybe);
- auto new_token = std::make_shared<NavigatorWriterToken>(type->getDescriptor(), type);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndList()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NavigatorWriter::writeStartTuple(const WriteStartTupleInput& o)
- {
- Path path = generatePath();
- auto type = std::make_shared<typenavigator::TupleNavigator>(path);
- type->setMaybe(o.maybe);
- auto new_token = std::make_shared<NavigatorWriterToken>(type->getDescriptor(), type);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndTuple()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NavigatorWriter::writeStartPair(const WriteStartPairInput& o)
- {
- Path path = generatePath();
- auto type = std::make_shared<typenavigator::PairNavigator>(path);
- type->setMaybe(o.maybe);
- auto new_token = std::make_shared<NavigatorWriterToken>(type->getDescriptor(), type);
- stack.push(new_token);
- }
-
- void NavigatorWriter::writeEndPair()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- auto prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
-
- template <class ElementT, class InputT>
- std::shared_ptr<ElementT>
- NavigatorWriter::writeElement(const InputT& input)
- {
- Path path = generatePath();
- NavigatorWriterTokenPtr token = stack.top();
- auto type = std::make_shared<ElementT>(path);
- type->setMaybe(input.maybe);
- token->addElement(type);
-
- return type;
- }
-
-
- void NavigatorWriter::writeEigenMatrix(const WriteEigenMatrixInput& o)
- {
- auto type = writeElement<typenavigator::EigenMatrixNavigator>(o);
-
- type->setRows(o.rows);
- type->setCols(o.cols);
- type->setTypename(o.type);
- }
-
- void NavigatorWriter::writeEigenQuaternion(const WriteEigenQuaternionInput& o)
- {
- auto type = writeElement<typenavigator::EigenQuaternionNavigator>(o);
-
- type->setTypename(o.type);
- }
-
-
- void NavigatorWriter::writeImage(const WriteImageInput& o)
- {
- auto type = writeElement<typenavigator::ImageNavigator>(o);
-
- type->setPixelType(o.pixelType);
- }
-
-
- void NavigatorWriter::writeIVTCByteImage(const WriteIVTCByteImageInput& o)
- {
- writeElement<typenavigator::IVTCByteImageNavigator>(o);
- }
-
- void NavigatorWriter::writeOpenCVMat(const WriteOpenCVMatInput& o)
- {
- writeElement<typenavigator::OpenCVMatNavigator>(o);
- }
-
- void NavigatorWriter::writePCLPointCloud(const WritePCLPointCloudInput& o)
- {
- auto type = writeElement<typenavigator::PCLPointCloudNavigator>(o);
-
- type->setTypename(o.type);
- }
-
- void NavigatorWriter::writePosition(const WritePositionInput& o)
- {
- writeElement<typenavigator::PositionNavigator>(o);
- }
-
- void NavigatorWriter::writeOrientation(const WriteOrientationInput& o)
- {
- writeElement<typenavigator::OrientationNavigator>(o);
- }
-
- void NavigatorWriter::writePose(const WritePoseInput& o)
- {
- writeElement<typenavigator::PoseNavigator>(o);
- }
-
- void NavigatorWriter::writeInt(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::IntNavigator>(o);
- }
-
- void NavigatorWriter::writeLong(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::LongNavigator>(o);
- }
-
- void NavigatorWriter::writeFloat(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::FloatNavigator>(o);
- }
-
- void NavigatorWriter::writeDouble(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::DoubleNavigator>(o);
- }
-
- void NavigatorWriter::writeString(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::StringNavigator>(o);
- }
-
- void NavigatorWriter::writeBool(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::BoolNavigator>(o);
- }
-
- void NavigatorWriter::writeTime(const WritePrimitiveInput& o)
- {
- writeElement<typenavigator::TimeNavigator>(o);
- }
-
- void NavigatorWriter::writeKey(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- void NavigatorWriter::writeExtends()
- {
- if (stack.size() < 2)
- {
- throw error::SizeNotValidException("NavigatorWriter", "writeExtends", "The stacksize must at least be 2 (one for base, one for derived)", stack.size(), 2);
- }
-
- auto base = stack.top();
- stack.pop();
- auto derived = stack.top();
-
- auto base_obj = typenavigator::ObjectNavigator::DynamicCastAndCheck(base->getElement());
- auto derived_obj = typenavigator::ObjectNavigator::DynamicCastAndCheck(derived->getElement());
- derived_obj->setExtends(base_obj);
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.h b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.h
deleted file mode 100644
index 80ca17960f4a454bf7c431ad64ce429835797403..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriterToken.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/Writer.h>
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-
-#include <memory>
-#include <stack>
-
-
-namespace armarx::aron::typeIO::writer
-{
- class NavigatorWriter;
- typedef std::shared_ptr<NavigatorWriter> NavigatorWriterPtr;
-
- class NavigatorWriter :
- virtual public typeIO::WriterInterface
- {
- public:
- NavigatorWriter() = default;
-
- virtual void writeStartObject(const WriteStartObjectInput&) override;
- virtual void writeEndObject() override;
- virtual void writeStartList(const WriteStartListInput&) override;
- virtual void writeEndList() override;
- virtual void writeStartDict(const WriteStartDictInput&) override;
- virtual void writeEndDict() override;
- virtual void writeStartTuple(const WriteStartTupleInput&) override;
- virtual void writeEndTuple() override;
- virtual void writeStartPair(const WriteStartPairInput&) override;
- virtual void writeEndPair() override;
-
- virtual void writeEigenMatrix(const WriteEigenMatrixInput&) override;
- virtual void writeEigenQuaternion(const WriteEigenQuaternionInput&) override;
- virtual void writeImage(const WriteImageInput&) override;
- virtual void writeIVTCByteImage(const WriteIVTCByteImageInput&) override;
- virtual void writeOpenCVMat(const WriteOpenCVMatInput&) override;
- virtual void writePCLPointCloud(const WritePCLPointCloudInput&) override;
- virtual void writePosition(const WritePositionInput&) override;
- virtual void writeOrientation(const WriteOrientationInput&) override;
- virtual void writePose(const WritePoseInput&) override;
-
- virtual void writeInt(const WritePrimitiveInput&) override;
- virtual void writeLong(const WritePrimitiveInput&) override;
- virtual void writeFloat(const WritePrimitiveInput&) override;
- virtual void writeDouble(const WritePrimitiveInput&) override;
- virtual void writeString(const WritePrimitiveInput&) override;
- virtual void writeBool(const WritePrimitiveInput&) override;
- virtual void writeTime(const WritePrimitiveInput&) override;
-
- virtual void writeKey(const std::string&) override;
- virtual void writeExtends() override;
-
- typenavigator::NavigatorPtr getResult() const
- {
- return lastRemovedToken->getElement();
- }
-
- private:
-
- Path generatePath();
-
- template <class ElementT, class InputT>
- std::shared_ptr<ElementT> writeElement(const InputT&);
-
-
- bool wroteInitialStartObject = false;
- NavigatorWriterTokenPtr lastRemovedToken = nullptr;
- std::stack<NavigatorWriterTokenPtr> stack = {};
-
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriterToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriterToken.h
deleted file mode 100644
index d94350f9df9a19ef04898b70e34449c883062a95..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriterToken.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/WriterToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx::aron::typeIO::writer
-{
- class NavigatorWriterToken;
- typedef std::shared_ptr<NavigatorWriterToken> NavigatorWriterTokenPtr;
-
- class NavigatorWriterToken :
- virtual public WriterTokenInterface<typenavigator::NavigatorPtr>
- {
- public:
- using PointerType = NavigatorWriterTokenPtr;
-
- public:
- // constructor
- NavigatorWriterToken() = delete;
- NavigatorWriterToken(const type::Descriptor desc, const typenavigator::NavigatorPtr& t)
- {
- descriptor = desc;
- element = t;
- }
-
- // virtual member functions
- virtual void addElement(const typenavigator::NavigatorPtr& n) override
- {
- switch (descriptor)
- {
- case type::Descriptor::eDict:
- {
- typenavigator::DictNavigatorPtr casted = typenavigator::DictNavigator::DynamicCastAndCheck(element);
- casted->setAcceptedType(n);
- break;
- }
- case type::Descriptor::eList:
- {
- typenavigator::ListNavigatorPtr casted = typenavigator::ListNavigator::DynamicCastAndCheck(element);
- casted->setAcceptedType(n);
- break;
- }
- case type::Descriptor::eObject:
- {
- typenavigator::ObjectNavigatorPtr casted = typenavigator::ObjectNavigator::DynamicCastAndCheck(element);
- casted->addMemberType(currentKey, n);
- break;
- }
- case type::Descriptor::eTuple:
- {
- typenavigator::TupleNavigatorPtr casted = typenavigator::TupleNavigator::DynamicCastAndCheck(element);
- casted->addAcceptedType(n);
- currentIndex++;
- break;
- }
- case type::Descriptor::ePair:
- {
- typenavigator::PairNavigatorPtr casted = typenavigator::PairNavigator::DynamicCastAndCheck(element);
- casted->addAcceptedType(n);
- currentIndex++;
- break;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorWriterToken", "addElement", "Could not resove a type of a navigator. Allowed are only containers. The path was: " + getElement()->pathToString(), descriptor);
- }
- }
-
-
- virtual void setName(const std::string& n) override
- {
- switch (descriptor)
- {
- case type::Descriptor::eObject:
- {
- typenavigator::ObjectNavigatorPtr casted = typenavigator::ObjectNavigator::DynamicCast(element);
- casted->setObjectName(n);
- break;
- }
- case type::Descriptor::eIntEnum:
- {
- typenavigator::IntEnumNavigatorPtr casted = typenavigator::IntEnumNavigator::DynamicCast(element);
- casted->setEnumName(n);
- break;
- }
- default:
- throw error::DescriptorNotValidException("NavigatorWriterToken", "setName", "Cant set the name of a non-object or non-enum token. The path was: " + getElement()->pathToString(), descriptor);
-
- }
- }
-
- private:
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
deleted file mode 100644
index aaafe280661a87ad411ab072a3dca5eed0fd7d53..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller (fabian dot peller at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include "NlohmannJSONWriter.h"
-
-namespace armarx::aron::typeIO::writer
-{
-
- void NlohmannJSONWriter::writeStartObject(const WriteStartObjectInput& o)
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_OBJECT_NAME_SLUG] = o.name;
- data[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(type::Descriptor::eObject, data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndObject()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NlohmannJSONWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeStartList(const WriteStartListInput& o)
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(type::Descriptor::eList, data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndList()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NlohmannJSONWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeStartDict(const WriteStartDictInput& o)
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(type::Descriptor::eDict, data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndDict()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NlohmannJSONWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeStartTuple(const WriteStartTupleInput& o)
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(type::Descriptor::eTuple, data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndTuple()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NlohmannJSONWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeStartPair(const WriteStartPairInput& o)
- {
- nlohmann::json data;
- data[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- auto new_token = std::make_shared<NlohmannJSONWriterToken>(type::Descriptor::ePair, data);
- stack.push(new_token);
- }
-
- void NlohmannJSONWriter::writeEndPair()
- {
- lastRemovedToken = stack.top();
- stack.pop();
-
- if (stack.size() > 0)
- {
- NlohmannJSONWriterTokenPtr prevToken = stack.top();
- prevToken->addElement(lastRemovedToken->getElement());
- }
- }
-
- void NlohmannJSONWriter::writeEigenMatrix(const WriteEigenMatrixInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "EigenMatrix";
- j[io::Data::READER_WRITER_NDARRAY_DIMENSIONS_SLUG] = std::vector<unsigned int>({o.rows, o.cols});
- j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG] = o.type;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeEigenQuaternion(const WriteEigenQuaternionInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "EigenQuaternion";
- j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG] = o.type;
- token->addElement(j);
- }
-
-
- void NlohmannJSONWriter::writeImage(const WriteImageInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "Image";
- j["pixelType"] = o.pixelType;
- token->addElement(j);
- }
-
-
- void NlohmannJSONWriter::writeIVTCByteImage(const WriteIVTCByteImageInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "IVTCByteImage";
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeOpenCVMat(const WriteOpenCVMatInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "OpenCVMat";
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePCLPointCloud(const WritePCLPointCloudInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "PCLPointCloud";
- j[io::Data::READER_WRITER_NDARRAY_TYPE_SLUG] = o.type;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePosition(const WritePositionInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "Position";
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeOrientation(const WriteOrientationInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "Orientation";
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writePose(const WritePoseInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- j[io::Data::READER_WRITER_NDARRAY_NAME_SLUG] = "Pose";
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeInt(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_INT_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeLong(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_LONG_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeFloat(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_FLOAT_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeDouble(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_DOUBLE_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeString(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_STRING_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeBool(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_BOOL_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeTime(const WritePrimitiveInput& o)
- {
- auto token = stack.top();
- nlohmann::json j;
- j[io::Data::READER_WRITER_TYPE_SLUG] = io::Data::READER_WRITER_TIME_TYPENAME_SLUG;
- j[io::Data::READER_WRITER_MAYBE_SLUG] = o.maybe;
- token->addElement(j);
- }
-
- void NlohmannJSONWriter::writeKey(const std::string& k)
- {
- auto token = stack.top();
- token->setCurrentKey(k);
- }
-
- void NlohmannJSONWriter::writeExtends()
- {
- if (stack.size() < 2)
- {
- throw error::SizeNotValidException("NavigatorWriter", "writeExtends", "The stacksize must at least be 2 (one for base, one for derived)", stack.size(), 2);
- }
-
- auto base = stack.top();
- stack.pop();
- auto derived = stack.top();
-
- if (!base->getElement().is_object())
- {
- throw error::AronException("NlohmannJSONWriter", "writeExtends", "Could not inherit from a non-object.");
- }
-
- if (!derived->getElement().is_object())
- {
- throw error::AronException("NlohmannJSONWriter", "writeExtends", "Could not inherit a non-object.");
- }
-
- derived->getElement()[io::Data::READER_WRITER_OBJECT_EXTENDS_SLUG] = base->getElement();
- }
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h
deleted file mode 100644
index b1a9b65483db764f7fa576c9f626a0e5b70477ca..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD / STL
-#include <memory>
-#include <stack>
-#include <sstream>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/typeIO/Writer.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h>
-
-namespace armarx::aron::typeIO::writer
-{
- class NlohmannJSONWriter :
- virtual public WriterInterface
- {
- public:
- NlohmannJSONWriter() = default;
-
- virtual void writeStartObject(const WriteStartObjectInput&) override;
- virtual void writeEndObject() override;
- virtual void writeStartList(const WriteStartListInput&) override;
- virtual void writeEndList() override;
- virtual void writeStartDict(const WriteStartDictInput&) override;
- virtual void writeEndDict() override;
- virtual void writeStartTuple(const WriteStartTupleInput&) override;
- virtual void writeEndTuple() override;
- virtual void writeStartPair(const WriteStartPairInput&) override;
- virtual void writeEndPair() override;
-
- virtual void writeEigenMatrix(const WriteEigenMatrixInput&) override;
- virtual void writeEigenQuaternion(const WriteEigenQuaternionInput&) override;
- virtual void writeImage(const WriteImageInput&) override;
- virtual void writeIVTCByteImage(const WriteIVTCByteImageInput&) override;
- virtual void writeOpenCVMat(const WriteOpenCVMatInput&) override;
- virtual void writePCLPointCloud(const WritePCLPointCloudInput&) override;
- virtual void writePosition(const WritePositionInput&) override;
- virtual void writeOrientation(const WriteOrientationInput&) override;
- virtual void writePose(const WritePoseInput&) override;
-
- virtual void writeInt(const WritePrimitiveInput&) override;
- virtual void writeLong(const WritePrimitiveInput&) override;
- virtual void writeFloat(const WritePrimitiveInput&) override;
- virtual void writeDouble(const WritePrimitiveInput&) override;
- virtual void writeString(const WritePrimitiveInput&) override;
- virtual void writeBool(const WritePrimitiveInput&) override;
- virtual void writeTime(const WritePrimitiveInput&) override;
-
- virtual void writeKey(const std::string&) override;
- virtual void writeExtends() override;
-
- nlohmann::json getResult() const
- {
- return lastRemovedToken->getElement();
- }
-
- private:
- bool wroteInitialStartObject = false;
- NlohmannJSONWriterTokenPtr lastRemovedToken = nullptr;
- std::stack<NlohmannJSONWriterTokenPtr> stack = {};
-
- Path generatePath();
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h b/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
deleted file mode 100644
index bea71d05b68deca116a253bbf9891ef29f7393a3..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriterToken.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller (fabian dot peller at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-
-// Simox
-#include <SimoxUtility/json.h>
-
-// Base Class
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/WriterToken.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Config.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron::typeIO::writer
-{
- class NlohmannJSONWriterToken;
- typedef std::shared_ptr<NlohmannJSONWriterToken> NlohmannJSONWriterTokenPtr;
-
- class NlohmannJSONWriterToken :
- virtual public WriterTokenInterface<nlohmann::json>
- {
- public:
- using PointerType = NlohmannJSONWriterTokenPtr;
-
- public:
- // constructor
- NlohmannJSONWriterToken() = delete;
- NlohmannJSONWriterToken(const type::Descriptor desc, const nlohmann::json& t)
- {
- descriptor = desc;
- element = t;
- }
-
- // virtual member functions
- virtual void addElement(const nlohmann::json& n) override
- {
- auto desc = getDescriptor();
- switch (desc)
- {
- case type::Descriptor::eDict:
- {
- element[io::Data::READER_WRITER_DICT_ACCEPTED_TYPE_SLUG] = n;
- break;
- }
- case type::Descriptor::eList:
- {
- element[io::Data::READER_WRITER_LIST_ACCEPTED_TYPE_SLUG] = n;
- break;
- }
- case type::Descriptor::eObject:
- {
- element[currentKey] = n;
- break;
- }
- case type::Descriptor::eTuple:
- {
- element.push_back(n);
- break;
- }
- default:
- throw error::DescriptorNotValidException("NlohmannJSONWriterToken", "addElement", "Could not resove a type of a navigator. Allowed are only containers.", desc);
- }
- }
-
- void setName(const std::string& n) override
- {
- auto desc = getDescriptor();
- if (desc != type::Descriptor::eObject)
- {
- throw error::DescriptorNotValidException("NlohmannJSONWriterToken", "setName", "Cant set the name of a non-object token.", desc);
- }
- element[io::Data::READER_WRITER_OBJECT_NAME_SLUG] = n;
- }
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.cpp b/source/RobotAPI/libraries/aron/core/legacy/DataVisitor.cpp
similarity index 96%
rename from source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.cpp
rename to source/RobotAPI/libraries/aron/core/legacy/DataVisitor.cpp
index 4715af4f46adba0d69ee0f1b7212930a21d3c866..f86ae598e2253bbb933e5c752b665634ee8d1d6c 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.cpp
+++ b/source/RobotAPI/libraries/aron/core/legacy/DataVisitor.cpp
@@ -18,10 +18,10 @@ namespace armarx::aron::visitor
}
- bool DataVisitor::applyTo(data::AronDataPtr& data)
+ bool DataVisitor::applyTo(data::dto::GenericDataPtr& data)
{
ARMARX_CHECK_NOT_NULL(data);
- return applyTo(*DataNavigator::FromAronData(data));
+ return applyTo(*DataNavigator::FromAronDTO(data));
}
bool DataVisitor::applyTo(DataVisitor::DataNavigator& navigator)
diff --git a/source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h b/source/RobotAPI/libraries/aron/core/legacy/DataVisitor.h
similarity index 87%
rename from source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h
rename to source/RobotAPI/libraries/aron/core/legacy/DataVisitor.h
index ad890f92e5e5cf59a04fdbf4a6b908b5069fb7d4..a5b3eb18c3ad13a3f191e359707261c0464d1e33 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/legacy/DataVisitor.h
@@ -2,14 +2,14 @@
#include <string>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
namespace armarx::aron::visitor
{
/**
- * @brief A visitor traversing an `aron::data::AronDataPtr` using
+ * @brief A visitor traversing an `aron::data::dto::GenericDataPtr` using
* `aron::datanavigator::Navigator`s, taking care of type checking,
* casting and hierarchical traversal.
*
@@ -30,7 +30,7 @@ namespace armarx::aron::visitor
* To the the location of the passed navigator in the original `AronData`,
* use `navigator.getPath()`.
*
- * @see `aron::data::AronDataPtr`
+ * @see `aron::data::dto::GenericDataPtr`
* @see `aron::datanavigator::Navigator`
* @see `std::stack` To manage data with stack semantics.
*/
@@ -40,18 +40,18 @@ namespace armarx::aron::visitor
// Define types to ease writing code in this and derived classes.
- using DataNavigator = datanavigator::Navigator;
+ using DataNavigator = data::Variant;
- using DictDataNavigator = datanavigator::DictNavigator;
- using ListDataNavigator = datanavigator::ListNavigator;
+ using DictDataNavigator = data::Dict;
+ using ListDataNavigator = data::List;
- using BoolDataNavigator = datanavigator::BoolNavigator;
- using DoubleDataNavigator = datanavigator::DoubleNavigator;
- using FloatDataNavigator = datanavigator::FloatNavigator;
- using IntDataNavigator = datanavigator::IntNavigator;
- using LongDataNavigator = datanavigator::LongNavigator;
- using NDArrayDataNavigator = datanavigator::NDArrayNavigator;
- using StringDataNavigator = datanavigator::StringNavigator;
+ using BoolDataNavigator = data::Bool;
+ using DoubleDataNavigator = data::Double;
+ using FloatDataNavigator = data::Float;
+ using IntDataNavigator = data::Int;
+ using LongDataNavigator = data::Long;
+ using NDArrayDataNavigator = data::NDArray;
+ using StringDataNavigator = data::String;
public:
@@ -60,7 +60,7 @@ namespace armarx::aron::visitor
virtual ~DataVisitor();
- bool applyTo(data::AronDataPtr& aronData);
+ bool applyTo(data::dto::GenericDataPtr& aronData);
bool applyTo(DataNavigator& navigator);
bool applyTo(const std::string& key, DataNavigator& navigator);
diff --git a/source/RobotAPI/libraries/aron/core/legacy/Randomizer.h b/source/RobotAPI/libraries/aron/core/legacy/Randomizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb068ebace153c2764a57c347a0bb904f7afa2f9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/legacy/Randomizer.h
@@ -0,0 +1,631 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <map>
+#include <memory>
+#include <numeric>
+#include <set>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+#include <RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
+
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+
+namespace armarx::aron
+{
+ namespace type::matrix
+ {
+ const std::vector<type::matrix::ElementType> AllTypes = {
+ type::matrix::ElementType::int16,
+ type::matrix::ElementType::int32,
+ type::matrix::ElementType::int64,
+ type::matrix::ElementType::float32,
+ type::matrix::ElementType::float64
+ };
+ }
+
+ namespace type::quaternion
+ {
+ const std::vector<type::quaternion::ElementType> AllTypes = {
+ type::quaternion::float32,
+ type::quaternion::float64
+ };
+ }
+
+ namespace type::image
+ {
+ const std::vector<type::image::PixelType> AllTypes = {
+ type::image::PixelType::rgb24,
+ type::image::PixelType::depth32
+ };
+ }
+
+ namespace type::pointcloud
+ {
+ const std::vector<type::pointcloud::VoxelType> AllTypes = {
+ type::pointcloud::VoxelType::PointXYZ,
+ type::pointcloud::VoxelType::PointXYZHSV,
+ type::pointcloud::VoxelType::PointXYZI,
+ type::pointcloud::VoxelType::PointXYZL,
+ type::pointcloud::VoxelType::PointXYZRGB,
+ type::pointcloud::VoxelType::PointXYZRGBA,
+ type::pointcloud::VoxelType::PointXYZRGBL
+ };
+ }
+
+ namespace util
+ {
+ // generate i in [min, max)
+ int generateRandom(int max, int min)
+ {
+ if (max < min)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The max value "+std::to_string(max)+" is lower than the min value "+std::to_string(min));
+ }
+ int random = (std::rand() % (max - min)) + min;
+ return random;
+ }
+
+ template <class T>
+ T getRandomElement(const std::vector<T>& vec)
+ {
+ int i = generateRandom(vec.size(), 0);
+ return vec.at(i);
+ }
+
+ template <class ValueT>
+ std::string getRandomKey(const std::map<std::string, ValueT>& m)
+ {
+ std::vector<std::string> keys;
+ for (const auto [k, _] : m)
+ {
+ keys.push_back(k);
+ }
+ return getRandomElement(keys);
+ }
+
+ std::string getRandomKey(const std::set<std::string>& set)
+ {
+ std::vector<std::string> keys;
+ for (const auto& k : set)
+ {
+ keys.push_back(k);
+ }
+ return getRandomElement(keys);
+ }
+
+ bool fiftyPercentChance()
+ {
+ return generateRandom(2, 0);
+ }
+
+ std::string generateRandomWord(const std::set<std::string>& usedKeys = {})
+ {
+ // https://randomwordgenerator.com/
+ // script to convert random words into string:
+ // jQuery("#result li i").remove(); var str = ""; jQuery("#result li").each(function() {str += jQuery(this).html() + ", " }); console.log(str);
+ const std::vector<std::string> words =
+ {
+ "jaw", "river", "bow", "profession", "heat", "interference", "slave", "population", "deport", "redeem", "digress", "penny", "cousin", "beef", "Bible", "fuss",
+ "urgency", "tasty", "innovation", "upset", "gold", "day", "remunerate", "strain", "district", "panel", "choke", "rack", "parameter", "despair", "extort", "country",
+ "hesitate", "record", "brand", "confusion", "discreet", "accept", "lifestyle", "option", "corn", "charity", "miss", "viable", "glance", "norm", "meet", "bird",
+ "ribbon", "guideline"
+ };
+
+ int i = generateRandom(words.size(), 0);
+ std::string key = words.at(i);
+
+ while (usedKeys.count(key) > 0)
+ {
+ key = generateRandomWord(usedKeys);
+ }
+
+ return key;
+ }
+
+ std::vector<unsigned char> generateRandomBlob(unsigned int size)
+ {
+ std::vector<unsigned char> new_blob(size, 0);
+ for (unsigned int i = 0; i < size; ++i)
+ {
+ new_blob[i] = (generateRandom(128, 0));
+ }
+ return new_blob;
+ }
+
+ struct RandomTypeGenerator : public type::Visitor<const type::Descriptor>
+ {
+ type::VariantPtr type;
+
+ static type::VariantPtr GenerateRandomType(bool can_be_maybe = true, bool must_be_object = false)
+ {
+ RandomTypeGenerator nt;
+ if (must_be_object)
+ {
+ type::visit(nt, type::Descriptor::eObject);
+ }
+ else
+ {
+ type::visit(nt, util::getRandomElement(type::AllDescriptors));
+ }
+
+ if (can_be_maybe)
+ {
+ type::Maybe nextMaybeType = util::getRandomElement(type::AllMaybeTypes);
+ nt.type->setMaybe(nextMaybeType);
+ }
+ return nt.type;
+ }
+
+ virtual type::Descriptor getDescriptor(Input& t) override { return t; }
+ virtual void visitObject(Input&) override
+ {
+ std::string objectName = util::generateRandomWord();
+
+ int members = util::generateRandom(4, 2);
+ std::set<std::string> usedKeys = {objectName};
+ std::map<std::string, type::VariantPtr> elements;
+ for (int i = 0; i < members; ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+ elements.insert({key, GenerateRandomType()});
+ }
+ type = std::make_shared<type::Object>(objectName, elements);
+ }
+ virtual void visitDict(Input&) override { type = std::make_shared<type::Dict>(GenerateRandomType()); }
+ virtual void visitPair(Input&) override { type = std::make_shared<type::Pair>(GenerateRandomType(), GenerateRandomType()); }
+ virtual void visitTuple(Input&) override
+ {
+ int members = util::generateRandom(4, 2);
+ std::vector<type::VariantPtr> acceptedTypes;
+ for (int i = 0; i < members; ++i)
+ {
+ acceptedTypes.push_back(GenerateRandomType());
+ }
+
+ type = std::make_shared<type::Tuple>(acceptedTypes);
+ }
+ virtual void visitList(Input&) override { type = std::make_shared<type::List>(GenerateRandomType()); }
+ virtual void visitMatrix(Input&) override
+ {
+ auto x = std::make_shared<type::Matrix>();
+ auto t = util::getRandomElement(type::matrix::AllTypes);
+ x->setElementType(t);
+ x->setRows(util::generateRandom(10, 1));
+ x->setRows(util::generateRandom(10, 1));
+ type = x;
+ }
+ virtual void visitNDArray(Input& t) override { visitMatrix(t); }
+ virtual void visitQuaternion(Input&) override
+ {
+ auto x = std::make_shared<type::Quaternion>();
+ auto t = util::getRandomElement(type::quaternion::AllTypes);
+ x->setElementType(t);
+ type = x;
+ }
+ virtual void visitOrientation(Input&) override { type = std::make_shared<type::Orientation>(); }
+ virtual void visitPosition(Input&) override { type = std::make_shared<type::Position>(); }
+ virtual void visitPose(Input&) override { type = std::make_shared<type::Pose>(); }
+ virtual void visitImage(Input&) override
+ {
+ auto t = std::make_shared<type::Image>();
+ auto x = util::getRandomElement(type::image::AllTypes);
+ t->setPixelType(x);
+ type = t;
+ }
+ virtual void visitPointCloud(Input&) override
+ {
+ auto t = std::make_shared<type::PointCloud>();
+ auto x = util::getRandomElement(type::pointcloud::AllTypes);
+ t->setVoxelType(x);
+ type = t;
+ }
+ virtual void visitIntEnum(Input&) override
+ {
+ std::string intEnumName = util::generateRandomWord();
+
+ std::set<std::string> usedKeys = {intEnumName};
+ std::map<std::string, int> acceptedValues;
+ for (int i = 0; i < util::generateRandom(5, 2); ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+
+ acceptedValues.insert({key, i});
+ }
+ type = std::make_shared<type::IntEnum>(intEnumName, acceptedValues);
+ }
+ virtual void visitInt(Input&) override { type = std::make_shared<type::Int>(); }
+ virtual void visitLong(Input&) override { type = std::make_shared<type::Long>(); }
+ virtual void visitFloat(Input&) override { type = std::make_shared<type::Float>(); }
+ virtual void visitDouble(Input&) override { type = std::make_shared<type::Double>(); }
+ virtual void visitBool(Input&) override { type = std::make_shared<type::Bool>(); }
+ virtual void visitString(Input&) override { type = std::make_shared<type::String>(); }
+ virtual void visitTime(Input&) override { type = std::make_shared<type::Time>(); }
+ virtual void visitUnknown(Input&) override { type = GenerateRandomType(); }
+ };
+
+ struct EmptyDataFromTypeGenerator : public type::Visitor<const type::Descriptor>
+ {
+ type::VariantPtr type;
+ data::VariantPtr data;
+
+ static data::VariantPtr GenerateRandomFromType(const type::VariantPtr& t)
+ {
+ EmptyDataFromTypeGenerator nt;
+ nt.type = t;
+ type::visit(nt, util::getRandomElement(type::AllDescriptors));
+ return nt.data;
+ }
+
+ virtual type::Descriptor getDescriptor(Input& t) override { return t; }
+ virtual void visitObject(Input&) override
+ {
+ auto da = std::make_shared<data::Dict>();
+
+ type::ObjectPtr t = type::Object::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::Dict>();
+ for (const auto& [k, tt] : t->getMemberTypes())
+ {
+ d->addElement(k, GenerateRandomFromType(tt));
+ }
+ data = da;
+ }
+ virtual void visitDict(Input&) override { data = std::make_shared<data::Dict>(); }
+ virtual void visitPair(Input&) override { data = std::make_shared<data::List>(); }
+ virtual void visitTuple(Input&) override { data = std::make_shared<data::List>(); }
+ virtual void visitList(Input&) override { data = std::make_shared<data::List>(); }
+ virtual void visitMatrix(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitNDArray(Input& t) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitQuaternion(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitOrientation(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitPosition(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitPose(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitImage(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitPointCloud(Input&) override { data = std::make_shared<data::NDArray>(); }
+ virtual void visitIntEnum(Input&) override { data = std::make_shared<data::Int>(); }
+ virtual void visitInt(Input&) override { data = std::make_shared<data::Int>(); }
+ virtual void visitLong(Input&) override { data = std::make_shared<data::Long>(); }
+ virtual void visitFloat(Input&) override { data = std::make_shared<data::Float>(); }
+ virtual void visitDouble(Input&) override { data = std::make_shared<data::Double>(); }
+ virtual void visitBool(Input&) override { data = std::make_shared<data::Bool>(); }
+ virtual void visitString(Input&) override { data = std::make_shared<data::String>(); }
+ virtual void visitTime(Input&) override { data = std::make_shared<data::Long>(); }
+ virtual void visitUnknown(Input&) override { data = GenerateRandomFromType(type); }
+ };
+ }
+
+ class Randomizer
+ {
+ public:
+ Randomizer()
+ {
+ std::srand(std::time(nullptr));
+ };
+
+ type::VariantPtr generateRandomObjectType() const
+ {
+ return util::RandomTypeGenerator::GenerateRandomType(false, true);
+ }
+
+ data::VariantPtr generateEmptyAronDataFromType(const type::VariantPtr& type, bool ignore_maybe = false) const
+ {
+ if (type->getMaybe() != type::Maybe::eNone && !ignore_maybe)
+ {
+ if (util::fiftyPercentChance())
+ {
+ return nullptr;
+ }
+ }
+
+ auto data = util::EmptyDataFromTypeGenerator::GenerateRandomFromType(type);
+ return data;
+ }
+
+ void initializeRandomly(data::VariantPtr& data, const type::VariantPtr& type) const
+ {
+ data = generateEmptyAronDataFromType(type);
+ if (!data)
+ {
+ if (type->getMaybe() == type::Maybe::eNone)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The data is null but the type is not a maybe type. This is not valid.");
+ }
+ return;
+ }
+
+ // Containers
+ type::Descriptor desc = type->getDescriptor();
+ switch (desc)
+ {
+ case type::Descriptor::eObject:
+ {
+ auto t = type::Object::DynamicCastAndCheck(type);
+ auto d = data::Dict::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eList:
+ {
+ auto t = type::List::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eDict:
+ {
+ auto t = type::Dict::DynamicCastAndCheck(type);
+ auto d = data::Dict::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eTuple:
+ {
+ auto t = type::Tuple::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePair:
+ {
+ auto t = type::Pair::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eIntEnum:
+ {
+ auto t = type::IntEnum::DynamicCastAndCheck(type);
+ auto d = data::Int::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eMatrix:
+ {
+ auto t = type::Matrix::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eNDArray:
+ {
+ auto t = type::NDArray::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eOrientation:
+ {
+ auto t = type::Orientation::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eQuaternion:
+ {
+ auto t = type::Quaternion::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eImage:
+ {
+ auto t = type::Image::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePointCloud:
+ {
+ auto t = type::PointCloud::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePosition:
+ {
+ auto t = type::Position::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePose:
+ {
+ auto t = type::Pose::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eInt:
+ {
+ auto t = type::Int::DynamicCastAndCheck(type);
+ auto d = data::Int::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eLong:
+ {
+ auto t = type::Long::DynamicCastAndCheck(type);
+ auto d = data::Long::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eFloat:
+ {
+ auto t = type::Float::DynamicCastAndCheck(type);
+ auto d = data::Float::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eDouble:
+ {
+ auto t = type::Double::DynamicCastAndCheck(type);
+ auto d = data::Double::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eString:
+ {
+ auto t = type::String::DynamicCastAndCheck(type);
+ auto d = data::String::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eBool:
+ {
+ auto t = type::Bool::DynamicCastAndCheck(type);
+ auto d = data::Bool::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eTime:
+ {
+ auto t = type::Time::DynamicCastAndCheck(type);
+ auto d = data::Long::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eUnknown:
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "No valid type found!");
+ }
+ }
+
+ }
+
+ void initializeRandomly(data::DictPtr& data, const type::Object& type) const
+ {
+ for (auto& [key, nextData] : data->getElements())
+ {
+ initializeRandomly(nextData, type.getMemberTypes()[key]);
+ data->removeElement(key);
+ data->addElement(key, nextData);
+ }
+ }
+
+ void initializeRandomly(data::DictPtr& data, const type::Dict& type) const
+ {
+ data->clear();
+ int numElements = util::generateRandom(5, 1);
+ std::set<std::string> usedKeys;
+ for (int i = 0; i < numElements; ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+ data::VariantPtr newData = generateEmptyAronDataFromType(type.getAcceptedType());
+ initializeRandomly(newData, type.getAcceptedType());
+ data->addElement(key, newData);
+ }
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::Tuple& type) const
+ {
+ std::vector<data::VariantPtr> newElements;
+
+ unsigned int i = 0;
+ for (auto& nextData : data->getElements())
+ {
+ initializeRandomly(nextData, type.getAcceptedType(i++));
+ newElements.push_back(nextData);
+ }
+
+ data->clear();
+ for (const auto& el : newElements)
+ {
+ data->addElement(el);
+ }
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::Pair& type) const
+ {
+ data::VariantPtr first = data->getElement(0);
+ data::VariantPtr second = data->getElement(1);
+ initializeRandomly(first, type.getFirstAcceptedType());
+ initializeRandomly(second, type.getSecondAcceptedType());
+
+ data->clear();
+ data->addElement(first);
+ data->addElement(second);
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::List& type) const
+ {
+ data->clear();
+ int numElements = util::generateRandom(5, 1);
+ for (int i = 0; i < numElements; ++i)
+ {
+ data::VariantPtr newData = generateEmptyAronDataFromType(type.getAcceptedType());
+ initializeRandomly(newData, type.getAcceptedType());
+ data->addElement(newData);
+ }
+ }
+
+ void initializeRandomly(data::NDArrayPtr& data, const type::Variant& type) const
+ {
+ std::vector<int> dims = data->getShape();
+ int bytes = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
+ std::vector<unsigned char> blob = util::generateRandomBlob(bytes);
+ data->setData(bytes, blob.data());
+ }
+
+ void initializeRandomly(data::IntPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::LongPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::FloatPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::DoublePtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::BoolPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::fiftyPercentChance());
+ }
+
+ void initializeRandomly(data::StringPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandomWord());
+ }
+ };
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.cpp b/source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.cpp
similarity index 90%
rename from source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.cpp
rename to source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.cpp
index fe98e3abe1d839928f9e3a78c2e52cb0e0717a20..cb129561e7242ed256ce7e89295647a3c9df90cb 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.cpp
+++ b/source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.cpp
@@ -49,20 +49,20 @@ namespace armarx::aron::visitor
return to;
}
template <class FromDataT>
- std::optional<datanavigator::LongNavigator> castToLong(const FromDataT& data)
+ std::optional<data::Long> castToLong(const FromDataT& data)
{
- if (auto d = dynamic_cast<const datanavigator::IntNavigator*>(&data))
+ if (auto d = dynamic_cast<const data::Int*>(&data))
{
- return cast<datanavigator::LongNavigator>(*d);
+ return cast<data::Long>(*d);
}
return std::nullopt;
}
template <class FromDataT>
- std::optional<datanavigator::IntNavigator> castToInt(const FromDataT& data)
+ std::optional<data::Int> castToInt(const FromDataT& data)
{
- if (auto d = dynamic_cast<const datanavigator::LongNavigator*>(&data))
+ if (auto d = dynamic_cast<const data::Long*>(&data))
{
- return cast<datanavigator::IntNavigator>(*d);
+ return cast<data::Int>(*d);
}
return std::nullopt;
}
@@ -159,14 +159,6 @@ namespace armarx::aron::visitor
{
return visit(*t, key, dynamic_cast<NDArrayDataNavigator&>(data));
}
- else if (auto t = dynamic_cast<IVTCByteImageTypeNavigator*>(&type))
- {
- return visit(*t, key, dynamic_cast<NDArrayDataNavigator&>(data));
- }
- else if (auto t = dynamic_cast<OpenCVMatTypeNavigator*>(&type))
- {
- return visit(*t, key, dynamic_cast<NDArrayDataNavigator&>(data));
- }
else if (auto t = dynamic_cast<PoseTypeNavigator*>(&type))
{
return visit(*t, key, dynamic_cast<NDArrayDataNavigator&>(data));
@@ -189,7 +181,7 @@ namespace armarx::aron::visitor
msg << "Got ARON data '" << simox::meta::get_type_name(data) << "'"
<< " incompatible to ARON type '" << simox::meta::get_type_name(type) << "'"
<< " (got std::bad_cast: '" << e.what() << "').";
- throw error::AronException("TypedDataVisitor", __FUNCTION__, msg.str());
+ throw error::AronException(__PRETTY_FUNCTION__, msg.str());
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.h b/source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.h
similarity index 80%
rename from source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.h
rename to source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.h
index b2efdaa79f0a8813c0a753822851789378ce73c7..bbc93f210289ef4540c05c434308867f3afe9817 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/visitors/TypedDataVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/legacy/TypedDataVisitor.h
@@ -1,14 +1,14 @@
#pragma once
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
namespace armarx::aron::visitor
{
/**
- * @brief A visitor traversing an `aron::Type::AronTypePtr` using
+ * @brief A visitor traversing an `aron::type::dto::GenericTypePtr` using
* `aron::Typenavigator::Navigator`s, taking care of type checking,
* casting and hierarchical traversal.
*
@@ -29,7 +29,7 @@ namespace armarx::aron::visitor
* To the the location of the passed navigator in the original `AronType`,
* use `navigator.getPath()`.
*
- * @see `aron::Type::AronTypePtr`
+ * @see `aron::type::dto::GenericTypePtr`
* @see `aron::Typenavigator::Navigator`
* @see `std::stack` To manage Type with stack semantics.
*/
@@ -40,52 +40,50 @@ namespace armarx::aron::visitor
// Define types to ease writing code in this and derived classes.
// Data - possible data representations
- using DataNavigator = datanavigator::Navigator;
+ using DataNavigator = data::Variant;
- using DictDataNavigator = datanavigator::DictNavigator;
- using ListDataNavigator = datanavigator::ListNavigator;
+ using DictDataNavigator = data::Dict;
+ using ListDataNavigator = data::List;
- using BoolDataNavigator = datanavigator::BoolNavigator;
- using DoubleDataNavigator = datanavigator::DoubleNavigator;
- using FloatDataNavigator = datanavigator::FloatNavigator;
- using IntDataNavigator = datanavigator::IntNavigator;
- using LongDataNavigator = datanavigator::LongNavigator;
- using StringDataNavigator = datanavigator::StringNavigator;
+ using BoolDataNavigator = data::Bool;
+ using DoubleDataNavigator = data::Double;
+ using FloatDataNavigator = data::Float;
+ using IntDataNavigator = data::Int;
+ using LongDataNavigator = data::Long;
+ using StringDataNavigator = data::String;
- using NDArrayDataNavigator = datanavigator::NDArrayNavigator;
+ using NDArrayDataNavigator = data::NDArray;
// Type
- using TypeNavigator = typenavigator::Navigator;
+ using TypeNavigator = type::Variant;
// Dict-valued
- using DictTypeNavigator = typenavigator::DictNavigator;
- using ObjectTypeNavigator = typenavigator::ObjectNavigator;
+ using DictTypeNavigator = type::Dict;
+ using ObjectTypeNavigator = type::Object;
// List-valued
- using ListTypeNavigator = typenavigator::ListNavigator;
- using TupleTypeNavigator = typenavigator::TupleNavigator;
+ using ListTypeNavigator = type::List;
+ using TupleTypeNavigator = type::Tuple;
// Primitive-valued
- using BoolTypeNavigator = typenavigator::BoolNavigator;
- using DoubleTypeNavigator = typenavigator::DoubleNavigator;
- using FloatTypeNavigator = typenavigator::FloatNavigator;
- using IntTypeNavigator = typenavigator::IntNavigator;
- using LongTypeNavigator = typenavigator::LongNavigator;
- using StringTypeNavigator = typenavigator::StringNavigator;
- using TimeTypeNavigator = typenavigator::TimeNavigator;
+ using BoolTypeNavigator = type::Bool;
+ using DoubleTypeNavigator = type::Double;
+ using FloatTypeNavigator = type::Float;
+ using IntTypeNavigator = type::Int;
+ using LongTypeNavigator = type::Long;
+ using StringTypeNavigator = type::String;
+ using TimeTypeNavigator = type::Time;
// Array-valued
- using EigenMatrixTypeNavigator = typenavigator::EigenMatrixNavigator;
- using EigenQuaternionTypeNavigator = typenavigator::EigenQuaternionNavigator;
- using ImageNavigator = typenavigator::ImageNavigator;
- using IVTCByteImageTypeNavigator = typenavigator::IVTCByteImageNavigator;
- using OpenCVMatTypeNavigator = typenavigator::OpenCVMatNavigator;
- using PCLPointCloudTypeNavigator = typenavigator::PCLPointCloudNavigator;
- using PoseTypeNavigator = typenavigator::PoseNavigator;
- using PositionTypeNavigator = typenavigator::PositionNavigator;
- using OrientationTypeNavigator = typenavigator::OrientationNavigator;
+ using EigenMatrixTypeNavigator = type::Matrix;
+ using EigenQuaternionTypeNavigator = type::Quaternion;
+ using ImageNavigator = type::Image;
+ using PCLPointCloudTypeNavigator = type::PointCloud;
+ using PoseTypeNavigator = type::Pose;
+ using PositionTypeNavigator = type::Position;
+ using OrientationTypeNavigator = type::Orientation;
public:
@@ -199,7 +197,7 @@ namespace armarx::aron::visitor
(void) type, (void) data;
return true;
}
- virtual bool visit(IVTCByteImageTypeNavigator& type, NDArrayDataNavigator& data)
+ /*virtual bool visit(IVTCByteImageTypeNavigator& type, NDArrayDataNavigator& data)
{
(void) type, (void) data;
return true;
@@ -208,7 +206,7 @@ namespace armarx::aron::visitor
{
(void) type, (void) data;
return true;
- }
+ }*/
virtual bool visit(PCLPointCloudTypeNavigator& type, NDArrayDataNavigator& data)
{
(void) type, (void) data;
@@ -334,7 +332,7 @@ namespace armarx::aron::visitor
(void) type, (void) key;
return visit(type, data);
}
- virtual bool visit(IVTCByteImageTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data)
+ /*virtual bool visit(IVTCByteImageTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data)
{
(void) type, (void) key;
return visit(type, data);
@@ -343,7 +341,7 @@ namespace armarx::aron::visitor
{
(void) type, (void) key;
return visit(type, data);
- }
+ }*/
virtual bool visit(PCLPointCloudTypeNavigator& type, const std::string& key, NDArrayDataNavigator& data)
{
(void) type, (void) key;
diff --git a/source/RobotAPI/libraries/aron/core/navigator/Navigator.h b/source/RobotAPI/libraries/aron/core/navigator/Navigator.h
deleted file mode 100644
index 0cd870ab77edc1a72f6cb5c90d8b820bde30b05e..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/Navigator.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-#include <RobotAPI/libraries/aron/core/Resolver.h>
-#include <RobotAPI/libraries/aron/core/Path.h>
-
-namespace armarx::aron
-{
- template <typename Descriptor, typename Aron> //requires isAron<Aron>&& isTypeDescriptor<Descriptor>
- class Navigator;
-
- template <typename Descriptor, typename Aron> //requires isAron<Aron>&& isTypeDescriptor<Descriptor>
- using NavigatorPtr = std::shared_ptr<Navigator<Descriptor, Aron>>;
-
- template <typename Descriptor, typename Aron> //requires isAron<Aron>&& isTypeDescriptor<Descriptor>
- class Navigator
- {
- public:
-
- // constructors
- Navigator() = default;
- Navigator(const Descriptor& descriptor, const Path& path) :
- descriptor(descriptor),
- path(path)
- {
- }
- virtual ~Navigator() = default;
-
- // public member functions
- Descriptor getDescriptor() const
- {
- return descriptor;
- }
-
- Path getPath() const
- {
- return path;
- }
-
- std::string pathToString() const
- {
- return path.toString();
- }
-
- // virtual definitions
- virtual typename Aron::PointerType toAronPtr() const = 0;
- virtual std::string getName() const = 0;
-
- protected:
-
- // members
- const Descriptor descriptor;
- const Path path;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h b/source/RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h
deleted file mode 100644
index 7e857a199fff69f5fe986161f2b524b80cbfef21..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "container/Dict.h"
-#include "container/List.h"
-#include "complex/NDArray.h"
-#include "primitive/Int.h"
-#include "primitive/Long.h"
-#include "primitive/Float.h"
-#include "primitive/Double.h"
-#include "primitive/String.h"
-#include "primitive/Bool.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.h b/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.h
deleted file mode 100644
index 5721a19d68e4a33e0df65130375eabc7ba5728ae..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/Navigator.h>
-#include <RobotAPI/libraries/aron/core/Path.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-
-namespace armarx::aron::datanavigator
-{
- class NavigatorFactory;
- typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
-
- class Navigator;
- typedef std::shared_ptr<Navigator> NavigatorPtr;
-
- class Navigator :
- virtual public aron::Navigator<data::Descriptor, data::AronData>
- {
- public:
- using PointerType = NavigatorPtr;
-
- public:
- // constructors
- Navigator() = default;
-
- // operators
- virtual bool operator==(const Navigator& other) const = 0;
- virtual bool operator==(const NavigatorPtr& other) const = 0;
-
- // static methods
- static NavigatorPtr FromAronData(const data::AronDataPtr&, const Path& = Path());
- static std::vector<NavigatorPtr> FromAronData(const std::vector<data::AronDataPtr>&, const Path& = Path());
- static std::vector<data::AronDataPtr> ToAronData(const std::vector<NavigatorPtr>&);
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCast(const NavigatorPtr& n)
- {
- return NavigatorT::DynamicCast(n);
- }
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCast(const Navigator& n)
- {
- return NavigatorT::DynamicCast(n);
- }
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCastAndCheck(const NavigatorPtr& n)
- {
- return NavigatorT::DynamicCastAndCheck(n);
- }
-
- // virtual definitions
- virtual std::vector<NavigatorPtr> getChildren() const = 0;
- virtual size_t childrenSize() const = 0;
-
- virtual typenavigator::NavigatorPtr recalculateType() const = 0;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const = 0;
-
- virtual NavigatorPtr navigateAbsolute(const Path& path) const;
- virtual NavigatorPtr navigateRelative(const Path& path) const;
-
- // public member functions
- data::AronDataPtr toAronDataPtr() const
- {
- return toAronPtr();
- }
-
- private:
- static const NavigatorFactoryPtr FACTORY;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp
deleted file mode 100644
index 6a4a62854a06a6f9c4457464b2d4f8035a66f012..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// STD/STL
-
-// Header
-#include "NavigatorFactory.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
-
-namespace armarx::aron::datanavigator
-{
-
- // Access method
- NavigatorPtr NavigatorFactory::create(const data::AronDataPtr& aron, const Path& path) const
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- {data::Descriptor::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
- static const std::map<data::Descriptor, NavigatorFactoryPtr> Factories =
- {
- HANDLE_ALL_ARON_DATA
- };
-#undef RUN_ARON_MACRO
-
- if (!aron)
- {
- return nullptr;
- }
-
- auto dataDescriptor = Resolver::GetDescriptor(aron);
- auto factory_iterator = Factories.find(dataDescriptor);
- if (factory_iterator == Factories.end())
- {
- throw error::AronException("NavigatorFactory", "create", "Cannot find the desired factory for input: " + data::DESCRIPTOR_TO_STRING(dataDescriptor) + ". Cannot create navigator", path);
- }
- return factory_iterator->second->createSpecific(aron, path);
- }
-
- NavigatorPtr NavigatorFactory::createSpecific(const data::AronDataPtr&, const Path& p) const
- {
- throw error::AronException("NavigatorFactory", "createSpecific", "Called disallowed method of an NavigatorFactory. Use child class instead!", p);
- }
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- NavigatorPtr upperType##NavigatorFactory::createSpecific(const data::AronDataPtr& aron, const Path& path) const \
- { \
- data::Aron##upperType##Ptr aronCasted = data::Aron##upperType##Ptr::dynamicCast(aron); \
- return datanavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
- }
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h
deleted file mode 100644
index 1838e7ac5178065c4e673a46f5d6cc1f1a6e7d4b..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <unordered_map>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/navigator/NavigatorFactory.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
-
-namespace armarx::aron::datanavigator
-{
- class NavigatorFactory;
- typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
-
- class NavigatorFactory :
- virtual public armarx::aron::
- NavigatorFactory<data::AronDataPtr, datanavigator::NavigatorPtr, data::Descriptor>
- {
- public:
- NavigatorFactory() = default;
- virtual ~NavigatorFactory() = default;
- virtual NavigatorPtr create(const data::AronDataPtr&, const Path&) const override;
- virtual NavigatorPtr createSpecific(const data::AronDataPtr&, const Path&) const override;
- };
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##NavigatorFactory : virtual public NavigatorFactory \
- { \
- public: \
- upperType##NavigatorFactory() = default; \
- virtual NavigatorPtr createSpecific(const data::AronDataPtr&, const Path&) const override; \
- };
-
- HANDLE_ALL_ARON_DATA
-#undef RUN_ARON_MACRO
-
-} // namespace armarx::aron::datanavigator
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFwd.h b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFwd.h
deleted file mode 100644
index 64ac3a8c95258d5c9585570935660252bbec58fb..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFwd.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * This file is part of ArmarX.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Reister ( fabian dot reister at kit dot edu )
- * @date 2021
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <memory>
-
-// TODO add forward declarations for those as well
-// #include "complex/NDArray.h"
-// #include "container/List.h"
-// #include "primitive/Bool.h"
-// #include "primitive/Double.h"
-// #include "primitive/Float.h"
-// #include "primitive/Int.h"
-// #include "primitive/Long.h"
-// #include "primitive/String.h"
-
-namespace armarx::aron::datanavigator
-{
- class DictNavigator;
- using DictNavigatorPtr = std::shared_ptr<DictNavigator>;
-
-} // namespace armarx::aron::datanavigator
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp
deleted file mode 100644
index cf568cef484224a6b24e5d292cfa910dee0b8994..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "NDArray.h"
-
-// Simox
-#include <SimoxUtility/algorithm/string.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h>
-
-namespace armarx::aron::datanavigator
-{
- // constructors
- NDArrayNavigator::NDArrayNavigator(const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eNDArray, path)
- {
-
- }
-
- NDArrayNavigator::NDArrayNavigator(const data::AronNDArrayPtr& o, const Path& path) :
- aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eNDArray, path),
- detail::NavigatorBase<data::AronNDArray, NDArrayNavigator>(o)
- {
- }
-
- NDArrayNavigator::NDArrayNavigator(const std::vector<int>& dim, const std::string& t, const std::vector<unsigned char>& data, const Path& path) :
- NDArrayNavigator(data::AronNDArrayPtr(new data::AronNDArray(dim, t, data)), path)
- {
- }
-
- // operators
- bool NDArrayNavigator::operator==(const NDArrayNavigator& other) const
- {
- const auto otherAron = other.toAronNDArrayPtr();
- if (aron->dimensions != otherAron->dimensions)
- {
- return false;
- }
- if (aron->type != otherAron->type)
- {
- return false;
- }
- // performs memcmp
- if (aron->data != otherAron->data)
- {
- return false;
- }
- return true;
- }
- bool NDArrayNavigator::operator==(const NDArrayNavigatorPtr& other) const
- {
- if (!other)
- {
- return false;
- }
- return *this == *other;
- }
-
- // static methods
- NDArrayNavigatorPtr NDArrayNavigator::FromAronNDArrayPtr(const data::AronNDArrayPtr& aron)
- {
- return std::make_shared<NDArrayNavigator>(aron);
- }
-
- data::AronNDArrayPtr NDArrayNavigator::ToAronNDArrayPtr(const NDArrayNavigatorPtr& navigator)
- {
- return navigator ? navigator->toAronNDArrayPtr() : nullptr;
- }
-
- // public member functions
- DictNavigatorPtr NDArrayNavigator::getAsDict() const
- {
- auto dict = std::make_shared<DictNavigator>();
- auto copy_this = FromAronData(toAronDataPtr(), getPath());
- dict->addElement("data", copy_this);
- return dict;
- }
-
- unsigned char* NDArrayNavigator::getData() const
- {
- return aron->data.data();
- }
-
- void NDArrayNavigator::setData(unsigned int elements, const unsigned char* src)
- {
- aron->data = std::vector<unsigned char>(elements);
- std::memcpy(aron->data.data(), src, elements);
- }
-
- std::vector<int> NDArrayNavigator::getDimensions() const
- {
- return aron->dimensions;
- }
-
- void NDArrayNavigator::setDimensions(const std::vector<int>& d)
- {
- aron->dimensions = d;
- }
-
- void NDArrayNavigator::addDimension(int i)
- {
- aron->dimensions.push_back(i);
- }
-
- std::string NDArrayNavigator::getType() const
- {
- return aron->type;
- }
-
- void NDArrayNavigator::setType(const std::string& t)
- {
- if (t.empty())
- {
- throw error::AronException("NDArrayNavigator", "setType", "The type cannot be empty", getPath());
- }
-
- aron->type = t;
- }
-
- data::AronNDArrayPtr NDArrayNavigator::toAronNDArrayPtr() const
- {
- return aron;
- }
-
- // virtual implementations
- std::string NDArrayNavigator::getName() const
- {
- return "AronNDArray<" + simox::alg::to_string(aron->dimensions, ", ") + ", " + aron->type + ">";
- }
-
- typenavigator::NavigatorPtr NDArrayNavigator::recalculateType() const
- {
- // We set all to openCVMat because it accepts n-dimensional types TODO
- typenavigator::OpenCVMatNavigatorPtr typenav = typenavigator::OpenCVMatNavigatorPtr(new typenavigator::OpenCVMatNavigator(getPath()));
- return typenav;
- }
-
- bool NDArrayNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
- {
- if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
- {
- return false;
- }
-
- switch (type->getDescriptor())
- {
- case type::Descriptor::eEigenMatrix:
- {
- auto casted = typenavigator::EigenMatrixNavigator::DynamicCast(type);
- if ((unsigned int) aron->dimensions[0] != casted->getRows() || (unsigned int) aron->dimensions[1] != casted->getCols())
- {
- return false;
- }
- break;
- }
- // TODO:
- default:
- throw error::AronException("NDArrayNavigator", "fullfillsType", "Could not cast a type to an NDArray-Type", getPath());
- }
- return true;
- }
-
- std::string NDArrayNavigator::DimensionsToString(const std::vector<int>& dimensions)
- {
- std::stringstream ss;
- ss << "(" << simox::alg::join(simox::alg::multi_to_string(dimensions), ", ") << ")";
- return ss.str();
- }
-
- std::vector<NavigatorPtr> NDArrayNavigator::getChildren() const
- {
- return {};
- }
-
- size_t NDArrayNavigator::childrenSize() const
- {
- return 0;
- }
-
-} // namespace armarx::aron::datanavigator
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h b/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h
deleted file mode 100644
index e41fbdb6518bc3e7f5f57999fc3fd3de2f14fa13..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <cstddef>
-#include <functional>
-#include <memory>
-#include <map>
-#include <numeric>
-#include <vector>
-
-// Base class
-#include "../detail/NavigatorBase.h"
-
-// ArmarX
-#include "../container/Dict.h"
-
-#include "../../type/ndarray/EigenMatrix.h"
-#include "../../type/ndarray/EigenQuaternion.h"
-#include "../../type/ndarray/IVTCByteImage.h"
-#include "../../type/ndarray/NDArray.h"
-#include "../../type/ndarray/OpenCVMat.h"
-#include "../../type/ndarray/Orientation.h"
-#include "../../type/ndarray/PCLPointCloud.h"
-#include "../../type/ndarray/Pose.h"
-#include "../../type/ndarray/Position.h"
-
-namespace armarx::aron::datanavigator
-{
- class NDArrayNavigator;
- using NDArrayNavigatorPtr = std::shared_ptr<NDArrayNavigator>;
-
- class NDArrayNavigator :
- virtual public detail::NavigatorBase<data::AronNDArray, NDArrayNavigator>
- {
- public:
- // constructors
- NDArrayNavigator(const Path& path = Path());
- NDArrayNavigator(const data::AronNDArrayPtr&, const Path& path = Path());
- NDArrayNavigator(const std::vector<int>&, const std::string&, const std::vector<unsigned char>&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const NDArrayNavigator&) const override;
- bool operator==(const NDArrayNavigatorPtr&) const override;
-
- // static methods
- static PointerType FromAronNDArrayPtr(const data::AronNDArrayPtr& aron);
- static data::AronNDArrayPtr ToAronNDArrayPtr(const PointerType& navigator);
-
- /// Return dimensions in a readable string such as "(2, 3, 4)".
- static std::string DimensionsToString(const std::vector<int>& dimensions);
-
- // public member functions
- DictNavigatorPtr getAsDict() const;
-
- unsigned char* getData() const;
- void setData(unsigned int, const unsigned char*);
-
- std::vector<int> getDimensions() const;
- void setDimensions(const std::vector<int>&);
- void addDimension(int);
-
- std::string getType() const;
- void setType(const std::string&);
-
- data::AronNDArrayPtr toAronNDArrayPtr() const;
-
- // virtual implementations
- virtual std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
-
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.h b/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.h
deleted file mode 100644
index 2ea343434d5d5c7b4ef77fce7b33525ceb2cd397..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <map>
-
-// Base class
-#include "../detail/NavigatorBase.h"
-
-// ArmarX
-#include "../../type/container/Dict.h"
-
-namespace armarx::aron::datanavigator
-{
- class DictNavigator;
- typedef std::shared_ptr<DictNavigator> DictNavigatorPtr;
-
- class DictNavigator :
- virtual public detail::NavigatorBase<data::AronDict, DictNavigator>
- {
- public:
- // constructors
- DictNavigator(const Path& path = Path());
- DictNavigator(const data::AronDictPtr&, const Path& path = Path());
- DictNavigator(const data::AronDataDict&, const Path& path = Path());
- DictNavigator(const std::map<std::string, NavigatorPtr>&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const DictNavigator&) const override;
- bool operator==(const DictNavigatorPtr&) const override;
-
- static PointerType FromAronDictPtr(const data::AronDictPtr& aron);
- static data::AronDictPtr ToAronDictPtr(const PointerType& navigator);
-
- // public member functions
- data::AronDictPtr toAronDictPtr() const;
- std::vector<std::string> getAllKeys() const;
- std::string getAllKeysAsString() const;
-
- void addElement(const std::string& key, const NavigatorPtr&);
- bool hasElement(const std::string&) const;
- NavigatorPtr getElement(const std::string&) const;
- std::map<std::string, NavigatorPtr> getElements() const;
-
- void clear();
-
- // virtual implementations
- virtual std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
-
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
-
- virtual NavigatorPtr navigateAbsolute(const Path& path) const override;
- virtual NavigatorPtr navigateRelative(const Path& path) const override;
-
- private:
- // members
- std::map<std::string, NavigatorPtr> childrenNavigators;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.h b/source/RobotAPI/libraries/aron/core/navigator/data/container/List.h
deleted file mode 100644
index 8df55ff032ba6a48b9651b011718f713484c26b2..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-
-// Base class
-#include "../detail/NavigatorBase.h"
-
-// ArmarX
-#include "Dict.h"
-#include "../../type/container/List.h"
-
-namespace armarx::aron::datanavigator
-{
- class ListNavigator;
- typedef std::shared_ptr<ListNavigator> ListNavigatorPtr;
-
- class ListNavigator :
- virtual public detail::NavigatorBase<data::AronList, ListNavigator>
- {
- public:
- // constructors
- ListNavigator(const Path& path = Path());
- ListNavigator(const data::AronListPtr&, const Path& path = Path());
- ListNavigator(const data::AronDataList&, const Path& path = Path());
- ListNavigator(const std::vector<NavigatorPtr>&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const ListNavigator&) const override;
- bool operator==(const ListNavigatorPtr&) const override;
-
- // static methods
- static PointerType FromAronListPtr(const data::AronListPtr& aron);
- static data::AronListPtr ToAronListPtr(const PointerType& navigator);
-
- // public member functions
- DictNavigatorPtr getAsDict() const;
-
- data::AronListPtr toAronListPtr() const;
-
- void addElement(const NavigatorPtr&);
- NavigatorPtr getElement(unsigned int) const;
- bool hasElement(unsigned int) const;
- std::vector<NavigatorPtr> getElements() const;
-
- void clear();
-
- // virtual implementations
- virtual std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
-
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
-
- virtual NavigatorPtr navigateAbsolute(const Path& path) const override;
- virtual NavigatorPtr navigateRelative(const Path& path) const override;
-
- private:
- std::vector<NavigatorPtr> childrenNavigators;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.cpp
deleted file mode 100644
index 5068d7dce5fce2a05fa8cd10684ff969de3353fe..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/detail/PrimitiveNavigatorBase.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PrimitiveNavigatorBase.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h b/source/RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h
deleted file mode 100644
index d76939c317aafd2acc4eb797d38d1ba1ff96da26..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/forward_declarations.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <memory>
-
-
-namespace armarx::aron::datanavigator
-{
- class Navigator;
- using NavigatorPtr = std::shared_ptr<Navigator>;
-
- using DictNavigatorPtr = std::shared_ptr<class DictNavigator>;
- using ListNavigatorPtr = std::shared_ptr<class ListNavigator>;
- using NDArrayNavigatorPtr = std::shared_ptr<class NDArrayNavigator>;
-
- using IntNavigatorPtr = std::shared_ptr<class IntNavigator>;
- using LongNavigatorPtr = std::shared_ptr<class LongNavigator>;
- using FloatNavigatorPtr = std::shared_ptr<class FloatNavigator>;
- using DoubleNavigatorPtr = std::shared_ptr<class DoubleNavigator>;
- using StringNavigatorPtr = std::shared_ptr<class StringNavigator>;
- using BoolNavigatorPtr = std::shared_ptr<class BoolNavigator>;
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.h b/source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.h
deleted file mode 100644
index 915334a9d8794245cb3c44c755ac5d3e39a7ddb5..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/String.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-
-// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
-
-// ArmarX
-#include "../../type/primitive/String.h"
-
-namespace armarx::aron::datanavigator
-{
-
- class StringNavigator;
- typedef std::shared_ptr<StringNavigator> StringNavigatorPtr;
-
- class StringNavigator :
- virtual public detail::PrimitiveNavigatorBase<data::AronString, std::string, StringNavigator>
- {
- public:
- /* constructors */
- StringNavigator(const Path& = Path());
- StringNavigator(const data::AronStringPtr&, const Path& = Path());
- StringNavigator(const std::string&, const Path& = Path());
-
- /* operators */
- bool operator==(const StringNavigator&) const override;
- bool operator==(const StringNavigatorPtr&) const override;
-
- /* static methods */
- static StringNavigatorPtr FromAronStringPtr(const data::AronStringPtr& aron);
- static data::AronStringPtr ToAronStringPtr(const StringNavigatorPtr& navigator);
-
- /* public member functions */
- data::AronStringPtr toAronStringPtr() const;
-
- /* virtual implementations */
- virtual std::string getName() const override;
-
- virtual typenavigator::NavigatorPtr recalculateType() const override;
- virtual bool fullfillsType(const typenavigator::NavigatorPtr&) const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h b/source/RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h
deleted file mode 100644
index 3a09c0a35f884d02f904eeaceee9dbd8b7a0c3c4..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "container/Dict.h"
-#include "container/List.h"
-#include "container/Object.h"
-#include "container/Pair.h"
-#include "container/Tuple.h"
-#include "ndarray/NDArray.h"
-#include "ndarray/EigenMatrix.h"
-#include "ndarray/EigenQuaternion.h"
-#include "ndarray/Image.h"
-#include "ndarray/IVTCByteImage.h"
-#include "ndarray/OpenCVMat.h"
-#include "ndarray/Orientation.h"
-#include "ndarray/PCLPointCloud.h"
-#include "ndarray/Pose.h"
-#include "ndarray/Position.h"
-#include "enum/IntEnum.h"
-#include "primitive/Int.h"
-#include "primitive/Long.h"
-#include "primitive/Float.h"
-#include "primitive/Double.h"
-#include "primitive/String.h"
-#include "primitive/Bool.h"
-#include "primitive/Time.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/Navigator.h b/source/RobotAPI/libraries/aron/core/navigator/type/Navigator.h
deleted file mode 100644
index 1ca45844db2cedd4cba004e94a57dde857ac491f..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/Navigator.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-* This file is part of ArmarX.
-*
-* Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
-* Karlsruhe Institute of Technology (KIT), all rights reserved.
-*
-* ArmarX is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License version 2 as
-* published by the Free Software Foundation.
-*
-* ArmarX is distributed in the hope that it will be useful, but
-* WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*
-* @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
-* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
-* GNU General Public License
-*/
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <vector>
-#include <map>
-#include <string>
-
-// Simox
-// #include <SimoxUtility/algorithm/string.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/Exception.h>
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/navigator/Navigator.h>
-
-namespace armarx::aron::typenavigator
-{
- class NavigatorFactory;
- typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
-
- class Navigator;
- typedef std::shared_ptr<Navigator> NavigatorPtr;
-
- class Navigator :
- virtual public aron::Navigator<type::Descriptor, type::AronType>
- {
- public:
- using PointerType = NavigatorPtr;
-
- public:
- // constructors
- Navigator() = default;
-
- // operators
- virtual bool operator==(const Navigator& other) const = 0;
- virtual bool operator==(const NavigatorPtr& other) const = 0;
-
- // static methods
- static NavigatorPtr FromAronType(const type::AronTypePtr&, const Path& = Path());
- static std::vector<NavigatorPtr> FromAronType(const std::vector<type::AronTypePtr>&, const Path& = Path());
- static std::vector<type::AronTypePtr> FromAronType(const std::vector<NavigatorPtr>&);
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCast(const NavigatorPtr& n)
- {
- return NavigatorT::DynamicCast(n);
- }
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCast(const Navigator& n)
- {
- return NavigatorT::DynamicCast(n);
- }
-
- template<typename NavigatorT>
- static typename NavigatorT::PointerType DynamicCastAndCheck(const NavigatorPtr& n)
- {
- return NavigatorT::DynamicCastAndCheck(n);
- }
-
- // virtual methods
- virtual std::vector<NavigatorPtr> getChildren() const = 0;
- virtual size_t childrenSize() const = 0;
- virtual void setMaybe(const type::Maybe m) = 0;
- virtual type::Maybe getMaybe() const = 0;
-
- // public member functions
- type::AronTypePtr toAronTypePtr() const
- {
- return toAronPtr();
- }
-
- private:
- static const NavigatorFactoryPtr FACTORY;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp
deleted file mode 100644
index f0375363b95993f9e216d1e140fa459ea99a6913..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// STD/STL
-
-// Header
-#include "NavigatorFactory.h"
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/AllNavigators.h>
-
-namespace armarx::aron::typenavigator
-{
- // Access method
- NavigatorPtr NavigatorFactory::create(const type::AronTypePtr& aron, const Path& path) const
- {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- {type::Descriptor::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
- static const std::map<type::Descriptor, NavigatorFactoryPtr> Factories =
- {
- HANDLE_ALL_ARON_TYPES
- };
-#undef RUN_ARON_MACRO
-
- auto typeDescriptor = Resolver::GetDescriptor(aron);
- auto factory_iterator = Factories.find(typeDescriptor);
- if (factory_iterator == Factories.end())
- {
- throw error::AronException("NavigatorFactory", "create", "Cannot find the desired factory for input: " + type::DESCRIPTOR_TO_STRING(typeDescriptor) + ". Cannot create navigator", path);
- }
- return factory_iterator->second->createSpecific(aron, path);
- }
-
- NavigatorPtr NavigatorFactory::createSpecific(const type::AronTypePtr&, const Path& p) const
- {
- throw error::AronException("NavigatorFactory", "createSpecific", "Called disallowed method of an NavigatorFactory. Use child class instead!", p);
- }
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- NavigatorPtr upperType##NavigatorFactory::createSpecific(const type::AronTypePtr& aron, const Path& path) const \
- { \
- type::Aron##upperType##Ptr aronCasted = type::Aron##upperType##Ptr::dynamicCast(aron); \
- return typenavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
- }
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h
deleted file mode 100644
index e470407db41466a817ce5d2bd8199c160819be24..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <memory>
-#include <unordered_map>
-
-// BaseClass
-#include <RobotAPI/libraries/aron/core/navigator/NavigatorFactory.h>
-
-// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/Navigator.h>
-#include <RobotAPI/libraries/aron/core/Descriptor.h>
-
-namespace armarx::aron::typenavigator
-{
- class NavigatorFactory;
- typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
-
- class NavigatorFactory :
- virtual public armarx::aron::NavigatorFactory<type::AronTypePtr, typenavigator::NavigatorPtr, type::Descriptor>
- {
- public:
- NavigatorFactory() = default;
- virtual typenavigator::NavigatorPtr create(const type::AronTypePtr&, const Path&) const override;
- virtual typenavigator::NavigatorPtr createSpecific(const type::AronTypePtr&, const Path&) const override;
- };
-
- // Factories
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
- class upperType##NavigatorFactory : \
- virtual public NavigatorFactory \
- { \
- public: \
- upperType##NavigatorFactory() = default; \
- virtual typenavigator::NavigatorPtr createSpecific(const type::AronTypePtr&, const Path&) const override; \
- };
-
- HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFwd.h b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFwd.h
deleted file mode 100644
index b5a9da2b9d05df4a0744a1d6074abcfff32aaafd..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFwd.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Reister ( fabian dot reister at kit dot edu )
- * @date 2021
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <memory>
-
-/// implemented
-// #include "container/List.h"
-// #include "container/Object.h"
-
-/// TODO add forward decl for those as well
-// #include "container/Pair.h"
-// #include "container/Tuple.h"
-// #include "enum/IntEnum.h"
-// #include "ndarray/EigenMatrix.h"
-// #include "ndarray/EigenQuaternion.h"
-// #include "ndarray/IVTCByteImage.h"
-// #include "ndarray/NDArray.h"
-// #include "ndarray/OpenCVMat.h"
-// #include "ndarray/Orientation.h"
-// #include "ndarray/PCLPointCloud.h"
-// #include "ndarray/Pose.h"
-// #include "ndarray/Position.h"
-// #include "primitive/Bool.h"
-// #include "primitive/Double.h"
-// #include "primitive/Float.h"
-// #include "primitive/Int.h"
-// #include "primitive/Long.h"
-// #include "primitive/String.h"
-// #include "primitive/Time.h"
-
-namespace armarx::aron::typenavigator
-{
- class DictNavigator;
- using DictNavigatorPtr = std::shared_ptr<DictNavigator>;
-
- class ListNavigator;
- using ListNavigatorPtr = std::shared_ptr<ListNavigator>;
-
-} // namespace armarx::aron::typenavigator
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.h b/source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.h
deleted file mode 100644
index b29a3ba35d6876bc4f34c36ea2daacd40eda4797..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-#include <map>
-
-// Base Class
-#include "../detail/ContainerNavigatorBase.h"
-
-namespace armarx::aron::typenavigator
-{
- class PairNavigator;
- typedef std::shared_ptr<PairNavigator> PairNavigatorPtr;
-
- class PairNavigator :
- virtual public detail::ContainerNavigatorBase<type::AronPair, PairNavigator>
- {
- public:
- // constructors
- PairNavigator(const Path& path = Path());
- PairNavigator(const type::AronPairPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const PairNavigator&) const override;
-
- // public member functions
- std::pair<NavigatorPtr, NavigatorPtr> getAcceptedTypes() const;
- NavigatorPtr getFirstAcceptedType() const;
- NavigatorPtr getSecondAcceptedType() const;
- void addAcceptedType(const NavigatorPtr&);
- void setFirstAcceptedType(const NavigatorPtr&);
- void setSecondAcceptedType(const NavigatorPtr&);
-
- type::AronPairPtr toAronPairPtr() const;
-
- // virtual implementations
- std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
-
- private:
- // members
- NavigatorPtr acceptedType1;
- NavigatorPtr acceptedType2;
-
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.cpp
deleted file mode 100644
index 5068d7dce5fce2a05fa8cd10684ff969de3353fe..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PrimitiveNavigatorBase.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.cpp
deleted file mode 100644
index 5068d7dce5fce2a05fa8cd10684ff969de3353fe..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PrimitiveNavigatorBase.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.cpp
deleted file mode 100644
index 5068d7dce5fce2a05fa8cd10684ff969de3353fe..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PrimitiveNavigatorBase.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h b/source/RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h
deleted file mode 100644
index e735771a906f47337a2db04a71448c8932a40b28..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/forward_declarations.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <memory>
-
-
-namespace armarx::aron::typenavigator
-{
- using NavigatorPtr = std::shared_ptr<class Navigator>;
-
- using DictNavigatorPtr = std::shared_ptr<class DictNavigator>;
- using ListNavigatorPtr = std::shared_ptr<class ListNavigator>;
- using ObjectNavigatorPtr = std::shared_ptr<class ObjectNavigator>;
- using PoseNavigatorPtr = std::shared_ptr<class PoseNavigator>;
- using TupleNavigatorPtr = std::shared_ptr<class TupleNavigator>;
- using NDArrayNavigatorPtr = std::shared_ptr<class NDArrayNavigator>;
- using EigenMatrixNavigatorPtr = std::shared_ptr<class EigenMatrixNavigator>;
- using EigenQuaternionNavigatorPtr = std::shared_ptr<class EigenQuaternionNavigator>;
- using ImageNavigatorPtr = std::shared_ptr<class ImageNavigator>;
- using IVTCByteImageNavigatorPtr = std::shared_ptr<class IVTCByteImageNavigator>;
- using OpenCVMatNavigatorPtr = std::shared_ptr<class OpenCVMatNavigator>;
- using OrientationNavigatorPtr = std::shared_ptr<class OrientationNavigator>;
- using PCLPointCloudNavigatorPtr = std::shared_ptr<class PCLPointCloudNavigator>;
- using PositionNavigatorPtr = std::shared_ptr<class PositionNavigator>;
- using IntEnumNavigatorPtr = std::shared_ptr<class IntEnumNavigator>;
-
- using IntNavigatorPtr = std::shared_ptr<class IntNavigator>;
- using LongNavigatorPtr = std::shared_ptr<class LongNavigator>;
- using FloatNavigatorPtr = std::shared_ptr<class FloatNavigator>;
- using DoubleNavigatorPtr = std::shared_ptr<class DoubleNavigator>;
- using StringNavigatorPtr = std::shared_ptr<class StringNavigator>;
- using BoolNavigatorPtr = std::shared_ptr<class BoolNavigator>;
- using TimeNavigatorPtr = std::shared_ptr<class TimeNavigator>;
-
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.cpp
deleted file mode 100644
index df5223b3c99df12055f6e9e7106b3f2cac1f53fd..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "EigenMatrix.h"
-
-// Simox
-#include <SimoxUtility/algorithm/vector.hpp>
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- EigenMatrixNavigator::EigenMatrixNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eEigenMatrix, path)
- {
- }
-
- EigenMatrixNavigator::EigenMatrixNavigator(const type::AronEigenMatrixPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eDict, path),
- detail::NavigatorBase<type::AronEigenMatrix, EigenMatrixNavigator>(o)
- {
- }
-
- // operators
- bool EigenMatrixNavigator::operator==(const EigenMatrixNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getCols() == other.getCols() && getRows() == other.getRows() && getTypename() == other.getTypename();
- }
-
- std::string EigenMatrixNavigator::checkTypename(const std::string& s) const
- {
- for (const auto& [key, list] : ACCEPTED_TYPES)
- {
- if (s == key)
- {
- return key;
- }
-
- for (const auto& el : list)
- {
- if (s == el)
- {
- return key;
- }
- }
- }
- throw error::StringNotValidException("EigenMatrixNavigator", "checkTypename", "The typename is wrong.", s, getPath());
- }
-
- unsigned int EigenMatrixNavigator::getRows() const
- {
- return this->aron->rows;
- }
-
- unsigned int EigenMatrixNavigator::getCols() const
- {
- return this->aron->cols;
- }
-
- void EigenMatrixNavigator::setRows(int w)
- {
- if (w == 0 || w < -1)
- {
- throw error::AronException("AronEigenMatrixNavigator", "setRows", "The rows cannot be 0 or < -1", getPath());
- }
- this->aron->rows = w;
- }
-
- void EigenMatrixNavigator::setCols(int h)
- {
- if (h == 0 || h < -1)
- {
- throw error::AronException("AronEigenMatrixNavigator", "setCols", "The cols cannot be 0 or < -1", getPath());
- }
- this->aron->cols = h;
- }
-
- std::string EigenMatrixNavigator::getTypename() const
- {
- return this->aron->typeName;
- }
-
- void EigenMatrixNavigator::setTypename(const std::string& u)
- {
- this->aron->typeName = checkTypename(u);;
- }
-
- type::AronEigenMatrixPtr EigenMatrixNavigator::toAronEigenMatrixPtr() const
- {
- return this->aron;
- }
-
- // virtual implementations
- std::string EigenMatrixNavigator::getName() const
- {
- return "AronEigenMatrix<" + std::to_string(this->aron->rows) + ", " + std::to_string(this->aron->cols) + ", " + this->aron->typeName + ">";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h
deleted file mode 100644
index 4cff659c1b9d063e54f786fb27230ff7cbd8d689..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-#include <map>
-
-// Base class
-#include "../detail/NDArrayNavigatorBase.h"
-
-namespace armarx::aron::typenavigator
-{
- class EigenMatrixNavigator;
- typedef std::shared_ptr<EigenMatrixNavigator> EigenMatrixNavigatorPtr;
-
- class EigenMatrixNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronEigenMatrix, EigenMatrixNavigator>
- {
- public:
- // constructors
- EigenMatrixNavigator(const Path& path = Path());
- EigenMatrixNavigator(const type::AronEigenMatrixPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const EigenMatrixNavigator&) const override;
-
- // public member functions
- std::string checkTypename(const std::string&) const;
-
- unsigned int getRows() const;
- unsigned int getCols() const;
- std::string getTypename() const;
-
- void setRows(int);
- void setCols(int);
- void setTypename(const std::string&);
-
- type::AronEigenMatrixPtr toAronEigenMatrixPtr() const;
-
- // virtual implementations
- virtual std::string getName() const override;
-
- public:
- const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
- {
- {"short", {}},
- {"int", {}},
- {"long", {}},
- {"float", {}},
- {"double", {}},
- //{"complex float", {"std::complex<float>"}},
- //{"complex double", {"std::complex<double>"}},
- };
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.cpp
deleted file mode 100644
index fbea54cbfe068e63adff2a16ef2fdb9dd168959e..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "EigenQuaternion.h"
-
-#include <SimoxUtility/algorithm/string/string_conversion.h>
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- EigenQuaternionNavigator::EigenQuaternionNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eEigenQuaternion, path)
- {
- }
-
- EigenQuaternionNavigator::EigenQuaternionNavigator(const type::AronEigenQuaternionPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eEigenQuaternion, path),
- detail::NavigatorBase<type::AronEigenQuaternion, EigenQuaternionNavigator>(o)
- {
- }
-
- // operators
- bool EigenQuaternionNavigator::operator==(const EigenQuaternionNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getTypename() == other.getTypename();
- }
-
- std::string EigenQuaternionNavigator::checkTypename(const std::string& s) const
- {
- for (const auto& [k, t] : ACCEPTED_TYPES)
- {
- if (s == k || std::find(t.begin(), t.end(), s) != t.end())
- {
- return k;
- }
- }
- throw error::StringNotValidException("EigenQuaternionNavigator", "checkTypename", "The typename is wrong.", s, getPath());
- }
-
- type::AronEigenQuaternionPtr EigenQuaternionNavigator::toAronEigenQuaternionPtr() const
- {
- return this->aron;
- }
-
- std::string EigenQuaternionNavigator::getTypename() const
- {
- return this->aron->typeName;
- }
-
- void EigenQuaternionNavigator::setTypename(const std::string& u)
- {
- this->aron->typeName = checkTypename(u);
- }
-
- // virtual implementations
- std::string EigenQuaternionNavigator::getName() const
- {
- return "AronEigenQuaternionType<" + simox::alg::to_string(ACCEPTED_DIMENSION, ", ") + ", " + this->aron->typeName + ">";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h
deleted file mode 100644
index 5112f7f21b2017f4c84982520983a49a9eafa20f..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-#include <map>
-
-// Base class
-#include "../detail/NDArrayNavigatorBase.h"
-
-namespace armarx::aron::typenavigator
-{
- class EigenQuaternionNavigator;
- typedef std::shared_ptr<EigenQuaternionNavigator> EigenQuaternionNavigatorPtr;
-
- class EigenQuaternionNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronEigenQuaternion, EigenQuaternionNavigator>
- {
- public:
- // constructors
- EigenQuaternionNavigator(const Path& path = Path());
- EigenQuaternionNavigator(const type::AronEigenQuaternionPtr&, const Path& path);
-
- // operators
- virtual bool operator==(const EigenQuaternionNavigator&) const override;
-
- // public member functions
- std::string checkTypename(const std::string&) const;
-
- std::string getTypename() const;
-
- void setTypename(const std::string&);
-
- type::AronEigenQuaternionPtr toAronEigenQuaternionPtr() const;
-
- // virtual implementations
- virtual std::string getName() const override;
-
- public:
- const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
- {
- {"float", {}},
- {"double", {}}
- };
- const std::vector<int> ACCEPTED_DIMENSION = {1, 4};
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.cpp
deleted file mode 100644
index dec13ece6cd10683ac5ffd6ac0f16af9c5a7e1a9..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#include "Image.h"
-
-#include <RobotAPI/libraries/aron/core/Exception.h>
-
-#include <SimoxUtility/algorithm/string.h>
-#include <SimoxUtility/meta/EnumNames.hpp>
-
-
-namespace armarx::aron::typenavigator
-{
-
- static const simox::meta::EnumNames<ImagePixelType> ImagePixelTypeNames
- {
- { ImagePixelType::Rgb24, "rgb24" },
- { ImagePixelType::Depth32, "depth32" },
- };
-
-
- // constructors
- ImageNavigator::ImageNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eImage, path)
- {
- }
-
-
- ImageNavigator::ImageNavigator(const type::AronImagePtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eImage, path),
- detail::NavigatorBase<type::AronImage, ImageNavigator>(o)
- {
- }
-
-
- type::AronImagePtr ImageNavigator::toAronImagePtr() const
- {
- return this->aron;
- }
-
-
- ImagePixelType ImageNavigator::getPixelType() const
- {
- return pixelTypeFromName(this->aron->pixelType);
- }
-
- void ImageNavigator::setPixelType(const ImagePixelType& pixelType) const
- {
- this->aron->pixelType = pixelTypeToName(pixelType);
- }
-
- void ImageNavigator::setPixelType(const std::string& typeName) const
- {
- // Try a lookup, which throws when failing.
- pixelTypeFromName(typeName);
- this->aron->pixelType = typeName;
- }
-
-
- // virtual implementations
- std::string ImageNavigator::getName() const
- {
- return "AronImageType";
- }
-
-
- bool ImageNavigator::operator==(const ImageNavigator& other) const
- {
- return *this->aron == *other.aron;
- }
-
-
- std::string ImageNavigator::pixelTypeToName(ImagePixelType type)
- {
- try
- {
- return ImagePixelTypeNames.to_name(type);
- }
- catch (const simox::meta::error::UnknownEnumValue& e)
- {
- throw aron::error::AronException("ImageNavigator", __FUNCTION__, e.what());
- }
- }
-
-
- ImagePixelType ImageNavigator::pixelTypeFromName(const std::string& name)
- {
- try
- {
- return ImagePixelTypeNames.from_name(simox::alg::to_lower(name));
- }
- catch (const simox::meta::error::UnknownEnumValue& e)
- {
- throw aron::error::AronException("ImageNavigator", __FUNCTION__, e.what());
- }
- }
-
-
- std::set<ImagePixelType> ImageNavigator::pixelTypes()
- {
- return ImagePixelTypeNames.values();
- }
-
- std::set<std::string> ImageNavigator::pixelTypeNames()
- {
- return ImagePixelTypeNames.names();
- }
-
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.h
deleted file mode 100644
index a725dfd161c9534902e10acd4c4a20e8183320ca..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Image.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-#include <RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.h>
-
-#include <memory>
-#include <string>
-
-
-namespace armarx::aron::typenavigator
-{
- enum class ImagePixelType
- {
- /// 3 (8-bit) byte channels for R, G, and B.
- Rgb24, // ==> CV_8UC1
- /// 1 (32-bit) float channel for depth.
- Depth32, // ==> CV_32FC1
- };
-
-
- class ImageNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronImage, ImageNavigator>
- {
- public:
-
- ImageNavigator(const Path& path = {});
- ImageNavigator(const type::AronImagePtr&, const Path& path);
-
-
- type::AronImagePtr toAronImagePtr() const;
-
- /// Get the pixel type.
- ImagePixelType getPixelType() const;
- void setPixelType(const ImagePixelType& type) const;
- void setPixelType(const std::string& typeName) const;
-
-
- // virtual implementations
- virtual std::string getName() const override;
-
-
- // operators
- virtual bool operator==(const ImageNavigator&) const override;
-
-
- public:
-
- static std::string pixelTypeToName(ImagePixelType type);
- static ImagePixelType pixelTypeFromName(const std::string& name);
- static std::set<ImagePixelType> pixelTypes();
- static std::set<std::string> pixelTypeNames();
-
- };
-
- using ImageNavigatorPtr = std::shared_ptr<ImageNavigator>;
-
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.cpp
deleted file mode 100644
index 14b7552ccbfdadd718113f99d62c40707bda7929..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "NDArray.h"
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- NDArrayNavigator::NDArrayNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eNDArray, path)
- {
- }
-
- NDArrayNavigator::NDArrayNavigator(const type::AronNDArrayPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eNDArray, path),
- detail::NavigatorBase<type::AronNDArray, NDArrayNavigator>(o)
- {
- }
-
- // operators
- bool NDArrayNavigator::operator==(const NDArrayNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getDimensions() == other.getDimensions() && getElementSize() == other.getElementSize() && getTypename() == other.getTypename();
- }
-
- type::AronNDArrayPtr NDArrayNavigator::toAronNDArrayPtr() const
- {
- return this->aron;
- }
-
- std::vector<int> NDArrayNavigator::getDimensions() const
- {
- return this->aron->dimensions;
- }
-
- std::string NDArrayNavigator::getTypename() const
- {
- return this->aron->typeName;
- }
-
- unsigned int NDArrayNavigator::getElementSize() const
- {
- return 0; //type->elementSize;
- }
-
- void NDArrayNavigator::setTypename(const std::string& s)
- {
- this->aron->typeName = s;
- }
-
- void NDArrayNavigator::setDimensions(const std::vector<int>& v)
- {
- this->aron->dimensions = v;
- }
-
- void NDArrayNavigator::addDimension(int i)
- {
- this->aron->dimensions.push_back(i);
- }
-
- void NDArrayNavigator::setElementSize(unsigned int i)
- {
- //type->elementSize = i;
- }
-
- // virtual implementations
- std::string NDArrayNavigator::getName() const
- {
- return "AronNDArrayType";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.cpp
deleted file mode 100644
index 76d8543d0f2348341ab5972214bc86e4205554b7..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "PCLPointCloud.h"
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- PCLPointCloudNavigator::PCLPointCloudNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePCLPointCloud, path)
- {
- }
-
- PCLPointCloudNavigator::PCLPointCloudNavigator(const type::AronPCLPointCloudPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePCLPointCloud, path),
- detail::NavigatorBase<type::AronPCLPointCloud, PCLPointCloudNavigator>(o)
- {
- checkTypename(this->aron->typeName);
- }
-
- // operators
- bool PCLPointCloudNavigator::operator==(const PCLPointCloudNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getTypename() == other.getTypename();
- }
-
- std::string PCLPointCloudNavigator::checkTypename(const std::string& s) const
- {
- for (const auto& [key, list] : ACCEPTED_TYPES)
- {
- if (s == key)
- {
- return key;
- }
-
- for (const auto& el : list)
- {
- if (s == el)
- {
- return key;
- }
- }
- }
- throw error::StringNotValidException("PCLPointCloudNavigator", "checkTypename", "The typename is wrong.", s, getPath());
- }
-
- type::AronPCLPointCloudPtr PCLPointCloudNavigator::toAronPCLPointCloudPtr() const
- {
- return this->aron;
- }
-
- std::string PCLPointCloudNavigator::getTypename() const
- {
- return this->aron->typeName;
- }
-
- void PCLPointCloudNavigator::setTypename(const std::string& u)
- {
- this->aron->typeName = checkTypename(u);
- }
-
- // virtual implementations
- std::string PCLPointCloudNavigator::getName() const
- {
- return "AronPCLPointCloudType<" + this->aron->typeName + ">";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.h
deleted file mode 100644
index 45cd8b8680af13101403820fe6d62447ed78b522..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/PCLPointCloud.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-#include <map>
-
-// Base class
-#include "../detail/NDArrayNavigatorBase.h"
-
-namespace armarx::aron::typenavigator
-{
- class PCLPointCloudNavigator;
- typedef std::shared_ptr<PCLPointCloudNavigator> PCLPointCloudNavigatorPtr;
-
- class PCLPointCloudNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronPCLPointCloud, PCLPointCloudNavigator>
- {
- public:
- // constructors
- PCLPointCloudNavigator(const Path& path = Path());
- PCLPointCloudNavigator(const type::AronPCLPointCloudPtr&, const Path& path);
-
- // operators
- virtual bool operator==(const PCLPointCloudNavigator&) const override;
-
- // public member functions
- std::string checkTypename(const std::string&) const;
-
- std::string getTypename() const;
-
- void setTypename(const std::string&);
-
- type::AronPCLPointCloudPtr toAronPCLPointCloudPtr() const;
-
- // virtual implementations
- virtual std::string getName() const override;
-
- public:
- const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
- {
- {"PointXYZ", {"pcl::PointXYZ"}},
- {"PointXYZI", {"pcl::PointXYZI"}},
- {"PointXYZL", {"pcl::PointXYZL"}},
- {"PointXYZRGB", {"pcl::PointXYZRGB"}},
- {"PointXYZRGBL", {"pcl::PointXYZRGBL"}},
- {"PointXYZRGBA", {"pcl::PointXYZRGBA"}},
- {"PointXYZHSV", {"pcl::PointXYZHSV"}}
- };
- const unsigned int ACCEPTED_DIMENSION_MIN_SIZE = 2;
- const unsigned int ACCEPTED_DIMENSION_MAX_SIZE = 2;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp
deleted file mode 100644
index 4db19f217776ba7e2eb68852c04fd412b3d6090d..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Pose.h"
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- PoseNavigator::PoseNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path)
- {
- }
-
- PoseNavigator::PoseNavigator(const type::AronPosePtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path),
- detail::NavigatorBase<type::AronPose, PoseNavigator>(o)
- {
- }
-
- // operators
- bool PoseNavigator::operator==(const PoseNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return true;
- }
-
- type::AronPosePtr PoseNavigator::toAronPosePtr() const
- {
- return this->aron;
- }
-
- // virtual implementations
- std::string PoseNavigator::getName() const
- {
- return "AronPoseType";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp
deleted file mode 100644
index ac46a301a4fb8514a8c5a1d49c7ee524333ef3fd..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-// Header
-#include "Position.h"
-
-namespace armarx::aron::typenavigator
-{
- // constructors
- PositionNavigator::PositionNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path)
- {
- }
-
- PositionNavigator::PositionNavigator(const type::AronPositionPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path),
- detail::NavigatorBase<type::AronPosition, PositionNavigator>(o)
- {
- }
-
- // operators
- bool PositionNavigator::operator==(const PositionNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return true;
- }
-
- type::AronPositionPtr PositionNavigator::toAronPositionPtr() const
- {
- return this->aron;
- }
-
- // virtual implementations
- std::string PositionNavigator::getName() const
- {
- return "AronPositionType";
- }
-}
-
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.h b/source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.h
deleted file mode 100644
index b661da12f3fe5a4fe2f35404f94816ec9a372245..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * This file is part of ArmarX.
- *
- * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
- * Karlsruhe Institute of Technology (KIT), all rights reserved.
- *
- * ArmarX is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * ArmarX is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
- * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
- * GNU General Public License
- */
-
-#pragma once
-
-// STD/STL
-#include <string>
-
-// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
-
-namespace armarx::aron::typenavigator
-{
- class StringNavigator;
- typedef std::shared_ptr<StringNavigator> StringNavigatorPtr;
-
- class StringNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronString, StringNavigator>
- {
- public:
- /* constructors */
- StringNavigator(const Path& = Path());
- StringNavigator(const type::AronStringPtr&, const Path& = Path());
-
- type::AronStringPtr toAronStringPtr() const;
-
- /* virtual implementations */
- virtual std::string getName() const override;
- };
-}
diff --git a/source/RobotAPI/libraries/aron/core/test/CMakeLists.txt b/source/RobotAPI/libraries/aron/core/test/CMakeLists.txt
index 4bc9abcc6c2e42529d3c80a5036a5af1a8e4f100..37aa8186e10627afbae5ccb8fff0bb52cf818617 100644
--- a/source/RobotAPI/libraries/aron/core/test/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/core/test/CMakeLists.txt
@@ -45,18 +45,16 @@ armarx_add_test(
# xmls/BaseClass.xml
# xmls/DerivedClassTest.xml
aron/DictTest.xml
- aron/EigenMatrixTest.xml
- aron/EigenQuaternionTest.xml
+ aron/MatrixTest.xml
+ aron/QuaternionTest.xml
aron/EnumTest.xml
aron/HumanPoseTest.xml
aron/ImageTest.xml
- aron/IVTCByteImageTest.xml
aron/ListTest.xml
aron/NaturalIKTest.xml
aron/ObjectTest.xml
- aron/OpenCVMatTest.xml
aron/OrientationTest.xml
- aron/PCLPointCloudTest.xml
+ aron/PointCloudTest.xml
aron/PoseTest.xml
aron/PositionTest.xml
aron/PrimitiveTest.xml
@@ -121,19 +119,18 @@ armarx_add_test(
ivt
ivtopencv
${PCL_COMMON_LIBRARIES}
+ aronjsonconverter
ARON_FILES
aron/DictTest.xml
- aron/EigenMatrixTest.xml
- aron/EigenQuaternionTest.xml
+ aron/MatrixTest.xml
+ aron/QuaternionTest.xml
aron/EnumTest.xml
aron/HumanPoseTest.xml
- aron/IVTCByteImageTest.xml
aron/ListTest.xml
aron/NaturalIKTest.xml
aron/ObjectTest.xml
- aron/OpenCVMatTest.xml
aron/OrientationTest.xml
- aron/PCLPointCloudTest.xml
+ aron/PointCloudTest.xml
aron/PoseTest.xml
aron/PositionTest.xml
aron/PrimitiveTest.xml
diff --git a/source/RobotAPI/libraries/aron/core/test/Randomizer.cpp b/source/RobotAPI/libraries/aron/core/test/Randomizer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e81ab45e0de25b7b307c43d40bc0a933da4bcfeb
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/test/Randomizer.cpp
@@ -0,0 +1,24 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Randomizer.h"
diff --git a/source/RobotAPI/libraries/aron/core/test/Randomizer.h b/source/RobotAPI/libraries/aron/core/test/Randomizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfc6328c28860191c8f5d6edc3b4e2b337599452
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/test/Randomizer.h
@@ -0,0 +1,827 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <map>
+#include <memory>
+#include <numeric>
+#include <set>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+#include <RobotAPI/libraries/aron/core/type/visitor/Visitor.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/Visitor.h>
+
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+
+#include <RobotAPI/libraries/aron/core/codegenerator/codewriter/cpp/generator/All.h>
+
+namespace armarx::aron
+{
+ namespace type::matrix
+ {
+ std::vector<type::matrix::ElementType> getAllTypes()
+ {
+ std::vector<type::matrix::ElementType> ret;
+ for(const auto& el : aron::codegenerator::cpp::generator::Matrix::ElementType2Cpp)
+ {
+ ret.push_back(el.first);
+ }
+ return ret;
+ }
+ const std::vector<type::matrix::ElementType> AllTypes = getAllTypes();
+ }
+
+ namespace type::quaternion
+ {
+ std::vector<type::quaternion::ElementType> getAllTypes()
+ {
+ std::vector<type::quaternion::ElementType> ret;
+ for(const auto& el : aron::codegenerator::cpp::generator::Quaternion::ElementType2Cpp)
+ {
+ ret.push_back(el.first);
+ }
+ return ret;
+ }
+ const std::vector<type::quaternion::ElementType> AllTypes = getAllTypes();
+ }
+
+ namespace type::image
+ {
+ std::vector<type::image::PixelType> getAllTypes()
+ {
+ std::vector<type::image::PixelType> ret;
+ for(const auto& el : aron::codegenerator::cpp::generator::Image::PixelType2Cpp)
+ {
+ ret.push_back(el.first);
+ }
+ return ret;
+ }
+ const std::vector<type::image::PixelType> AllTypes = getAllTypes();
+ }
+
+ namespace type::pointcloud
+ {
+ std::vector<type::pointcloud::VoxelType> getAllTypes()
+ {
+ std::vector<type::pointcloud::VoxelType> ret;
+ for(const auto& el : aron::codegenerator::cpp::generator::PointCloud::VoxelType2Cpp)
+ {
+ ret.push_back(el.first);
+ }
+ return ret;
+ }
+ const std::vector<type::pointcloud::VoxelType> AllTypes = getAllTypes();
+ }
+
+ namespace util
+ {
+ // generate i in [min, max)
+ int generateRandom(int max, int min)
+ {
+ if (max < min)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The max value "+std::to_string(max)+" is lower than the min value "+std::to_string(min));
+ }
+ int random = (std::rand() % (max - min)) + min;
+ return random;
+ }
+
+ template <class T>
+ T getRandomElement(const std::vector<T>& vec)
+ {
+ int i = generateRandom(vec.size(), 0);
+ return vec.at(i);
+ }
+
+ template <class ValueT>
+ std::string getRandomKey(const std::map<std::string, ValueT>& m)
+ {
+ std::vector<std::string> keys;
+ for (const auto [k, _] : m)
+ {
+ keys.push_back(k);
+ }
+ return getRandomElement(keys);
+ }
+
+ std::string getRandomKey(const std::set<std::string>& set)
+ {
+ std::vector<std::string> keys;
+ for (const auto& k : set)
+ {
+ keys.push_back(k);
+ }
+ return getRandomElement(keys);
+ }
+
+ bool fiftyPercentChance()
+ {
+ return generateRandom(2, 0);
+ }
+
+ std::string generateRandomWord(const std::set<std::string>& usedKeys = {})
+ {
+ // https://randomwordgenerator.com/
+ // script to convert random words into string:
+ // jQuery("#result li i").remove(); var str = ""; jQuery("#result li").each(function() {str += jQuery(this).html() + ", " }); console.log(str);
+ const std::vector<std::string> words =
+ {
+ "jaw", "river", "bow", "profession", "heat", "interference", "slave", "population", "deport", "redeem", "digress", "penny", "cousin", "beef", "Bible", "fuss",
+ "urgency", "tasty", "innovation", "upset", "gold", "day", "remunerate", "strain", "district", "panel", "choke", "rack", "parameter", "despair", "extort", "country",
+ "hesitate", "record", "brand", "confusion", "discreet", "accept", "lifestyle", "option", "corn", "charity", "miss", "viable", "glance", "norm", "meet", "bird",
+ "ribbon", "guideline"
+ };
+
+ int i = generateRandom(words.size(), 0);
+ std::string key = words.at(i);
+
+ while (usedKeys.count(key) > 0)
+ {
+ key = generateRandomWord(usedKeys);
+ }
+
+ return key;
+ }
+
+ std::vector<unsigned char> generateRandomBlob(unsigned int size)
+ {
+ std::vector<unsigned char> new_blob(size, 0);
+ for (unsigned int i = 0; i < size; ++i)
+ {
+ new_blob[i] = (generateRandom(128, 0));
+ }
+ return new_blob;
+ }
+ }
+
+ class Randomizer
+ {
+ public:
+ Randomizer()
+ {
+ std::srand(std::time(nullptr));
+ };
+
+ type::VariantPtr generateRandomType(bool allowMaybeType = false, bool firstObject = false) const
+ {
+ type::Descriptor nextType = type::Descriptor::eObject;
+ if (!firstObject)
+ {
+ nextType = util::getRandomElement(type::AllDescriptors);
+ }
+
+ type::Maybe nextMaybeType = type::Maybe::eNone;
+ if (allowMaybeType && !firstObject)
+ {
+ nextMaybeType = util::getRandomElement(type::AllMaybeTypes);
+ }
+ (void) nextMaybeType; //unused
+
+ switch (nextType)
+ {
+ case type::Descriptor::eObject:
+ {
+ std::string objectName = util::generateRandomWord();
+
+ int members = util::generateRandom(4, 2);
+ std::set<std::string> usedKeys = {objectName};
+ std::map<std::string, type::VariantPtr> elements;
+ for (int i = 0; i < members; ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+
+ type::VariantPtr m = generateRandomType(false);
+ elements.insert({key, m});
+ }
+
+ auto t = std::make_shared<type::Object>(objectName, elements);
+ return t;
+ }
+ case type::Descriptor::eIntEnum:
+ {
+ std::string intEnumName = util::generateRandomWord();
+
+ std::set<std::string> usedKeys = {intEnumName};
+ std::map<std::string, int> acceptedValues;
+ for (int i = 0; i < util::generateRandom(5, 2); ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+
+ acceptedValues.insert({key, i});
+ }
+ auto t = std::make_shared<type::IntEnum>(intEnumName, acceptedValues);
+ return t;
+ }
+ case type::Descriptor::eDict:
+ {
+ type::VariantPtr a = generateRandomType(false);
+ auto t = std::make_shared<type::Dict>(a);
+ return t;
+ }
+ case type::Descriptor::eTuple:
+ {
+ int members = util::generateRandom(4, 2);
+ std::vector<type::VariantPtr> acceptedTypes;
+ for (int i = 0; i < members; ++i)
+ {
+ type::VariantPtr m = generateRandomType(false);
+ acceptedTypes.push_back(m);
+ }
+
+ auto t = std::make_shared<type::Tuple>(acceptedTypes);
+ return t;
+ }
+ case type::Descriptor::eList:
+ {
+ type::VariantPtr a = generateRandomType(false);
+
+ auto t = std::make_shared<type::List>(a);
+ return t;
+ }
+ case type::Descriptor::ePair:
+ {
+ type::VariantPtr a = generateRandomType(false);
+ type::VariantPtr b = generateRandomType(false);
+
+ auto t = std::make_shared<type::Pair>(a,b);
+ return t;
+ }
+ case type::Descriptor::eNDArray:
+ {
+ // TODO (fabian.peller)
+ // fall through EigenMatrix
+ }
+ case type::Descriptor::eMatrix:
+ {
+ auto t = std::make_shared<type::Matrix>();
+ auto type = util::getRandomElement(type::matrix::AllTypes);
+ t->setElementType(type);
+ t->setRows(util::generateRandom(10, 1));
+ t->setRows(util::generateRandom(10, 1));
+ return t;
+ }
+ case type::Descriptor::eQuaternion:
+ {
+ auto t = std::make_shared<type::Quaternion>();
+ auto type = util::getRandomElement(type::quaternion::AllTypes);
+ t->setElementType(type);
+ return t;
+ }
+ case type::Descriptor::eImage:
+ {
+ auto t = std::make_shared<type::Image>();
+ auto type = util::getRandomElement(type::image::AllTypes);
+ t->setPixelType(type);
+ return t;
+ }
+ case type::Descriptor::ePointCloud:
+ {
+ auto t = std::make_shared<type::PointCloud>();
+ auto type = util::getRandomElement(type::pointcloud::AllTypes);
+ t->setVoxelType(type);
+ return t;
+ }
+ case type::Descriptor::ePosition:
+ {
+ auto t = std::make_shared<type::Position>();
+ return t;
+ }
+ case type::Descriptor::eOrientation:
+ {
+ auto t = std::make_shared<type::Position>();
+ return t;
+ }
+ case type::Descriptor::ePose:
+ {
+ auto t = std::make_shared<type::Position>();
+ return t;
+ }
+ case type::Descriptor::eInt:
+ {
+ auto t = std::make_shared<type::Int>();
+ return t;
+ }
+ case type::Descriptor::eLong:
+ {
+ auto t = std::make_shared<type::Long>();
+ return t;
+ }
+ case type::Descriptor::eFloat:
+ {
+ auto t = std::make_shared<type::Float>();
+ return t;
+ }
+ case type::Descriptor::eDouble:
+ {
+ auto t = std::make_shared<type::Double>();
+ return t;
+ }
+ case type::Descriptor::eString:
+ {
+ auto t = std::make_shared<type::String>();
+ return t;
+ }
+ case type::Descriptor::eBool:
+ {
+ auto t = std::make_shared<type::Bool>();
+ return t;
+ }
+ case type::Descriptor::eTime:
+ {
+ auto t = std::make_shared<type::Time>();
+ return t;
+ }
+ case type::Descriptor::eUnknown:
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "No valid type found!");
+ }
+ }
+ }
+
+ data::VariantPtr generateEmptyAronDataFromType(const type::VariantPtr& type, bool ignore_maybe = false) const
+ {
+ if (type->getMaybe() != type::Maybe::eNone && !ignore_maybe)
+ {
+ if (util::fiftyPercentChance())
+ {
+ return nullptr;
+ }
+ }
+
+ const type::Descriptor desc = type->getDescriptor();
+ switch (desc)
+ {
+ // In an object, we do not want to edit the keys.
+ case type::Descriptor::eObject:
+ {
+ type::ObjectPtr t = type::Object::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::Dict>();
+ for (const auto& [k, tt] : t->getMemberTypes())
+ {
+ d->addElement(k, generateEmptyAronDataFromType(tt));
+ }
+ return d;
+ }
+
+ case type::Descriptor::eIntEnum:
+ {
+ auto t = type::IntEnum::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::Int>();
+ return d;
+ }
+
+ // here all totally random
+ case type::Descriptor::eDict:
+ {
+ auto t = type::Dict::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Dict());
+ }
+
+ case type::Descriptor::eList:
+ {
+ auto t = type::List::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::List());
+ }
+
+ case type::Descriptor::ePair:
+ {
+ auto t = type::Pair::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::List());
+ }
+
+ case type::Descriptor::eTuple:
+ {
+ auto t = type::Tuple::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::List());
+ }
+
+ case type::Descriptor::eMatrix:
+ {
+ auto t = type::Matrix::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({(int) t->getRows(), (int) t->getCols(), aron::codegenerator::cpp::generator::Matrix::ElementType2Cpp.at(t->getElementType()).second});
+ d->setType(aron::codegenerator::cpp::generator::Matrix::ElementType2Cpp.at(t->getElementType()).first);
+ return d;
+ }
+
+ case type::Descriptor::eQuaternion:
+ {
+ auto t = type::Quaternion::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({1, 4, aron::codegenerator::cpp::generator::Quaternion::ElementType2Cpp.at(t->getElementType()).second});
+ d->setType(aron::codegenerator::cpp::generator::Quaternion::ElementType2Cpp.at(t->getElementType()).first);
+ return d;
+ }
+
+ case type::Descriptor::eImage:
+ {
+ auto t = type::Image::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({util::generateRandom(10, 1), util::generateRandom(10, 1), aron::codegenerator::cpp::generator::Image::PixelType2Cpp.at(t->getPixelType()).second});
+ d->setType("5");
+ return d;
+ }
+
+ case type::Descriptor::ePointCloud:
+ {
+ auto t = type::PointCloud::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({util::generateRandom(10, 1), util::generateRandom(10, 1), aron::codegenerator::cpp::generator::PointCloud::VoxelType2Cpp.at(t->getVoxelType()).second});
+ d->setType(aron::codegenerator::cpp::generator::PointCloud::VoxelType2Cpp.at(t->getVoxelType()).first);
+ return d;
+ }
+
+ case type::Descriptor::ePose:
+ {
+ auto t = type::Pose::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({4, 4, 4});
+ d->setType("float");
+ return d;
+ }
+
+ case type::Descriptor::ePosition:
+ {
+ auto t = type::Position::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({3, 1, 4});
+ d->setType("float");
+ return d;
+ }
+
+ case type::Descriptor::eOrientation:
+ {
+ auto t = type::Orientation::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ d->setShape({1, 4, 4});
+ d->setType("float");
+ return d;
+ }
+
+ case type::Descriptor::eNDArray:
+ {
+ auto t = type::NDArray::DynamicCastAndCheck(type);
+ auto d = std::make_shared<data::NDArray>();
+ return d;
+ }
+
+ case type::Descriptor::eInt:
+ {
+ auto t = type::Int::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Int());
+ }
+
+ case type::Descriptor::eLong:
+ {
+ auto t = type::Long::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Long());
+ }
+
+ case type::Descriptor::eFloat:
+ {
+ auto t = type::Float::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Float());
+ }
+
+ case type::Descriptor::eDouble:
+ {
+ auto t = type::Double::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Double());
+ }
+
+ case type::Descriptor::eString:
+ {
+ auto t = type::String::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::String());
+ }
+
+ case type::Descriptor::eBool:
+ {
+ auto t = type::Bool::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Bool());
+ }
+
+ case type::Descriptor::eTime:
+ {
+ auto t = type::Time::DynamicCastAndCheck(type);
+ return data::VariantPtr(new data::Long());
+ }
+
+ default:
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "No valid type found!");
+ }
+ }
+ }
+
+ void initializeRandomly(data::VariantPtr& data, const type::VariantPtr& type, bool use_existing_data = true) const
+ {
+ if (!use_existing_data)
+ {
+ data = generateEmptyAronDataFromType(type);
+ }
+ if (!data)
+ {
+ if (type->getMaybe() == type::Maybe::eNone)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The data is null but the type is not a maybe type. This is not valid.");
+ }
+ return;
+ }
+
+ // Containers
+ type::Descriptor desc = type->getDescriptor();
+ switch (desc)
+ {
+ case type::Descriptor::eObject:
+ {
+ auto t = type::Object::DynamicCastAndCheck(type);
+ auto d = data::Dict::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eList:
+ {
+ auto t = type::List::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eDict:
+ {
+ auto t = type::Dict::DynamicCastAndCheck(type);
+ auto d = data::Dict::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eTuple:
+ {
+ auto t = type::Tuple::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePair:
+ {
+ auto t = type::Pair::DynamicCastAndCheck(type);
+ auto d = data::List::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eIntEnum:
+ {
+ auto t = type::IntEnum::DynamicCastAndCheck(type);
+ auto d = data::Int::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eMatrix:
+ {
+ auto t = type::Matrix::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eNDArray:
+ {
+ auto t = type::NDArray::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eOrientation:
+ {
+ auto t = type::Orientation::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eQuaternion:
+ {
+ auto t = type::Quaternion::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eImage:
+ {
+ auto t = type::Image::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePointCloud:
+ {
+ auto t = type::PointCloud::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePosition:
+ {
+ auto t = type::Position::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::ePose:
+ {
+ auto t = type::Pose::DynamicCastAndCheck(type);
+ auto d = data::NDArray::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eInt:
+ {
+ auto t = type::Int::DynamicCastAndCheck(type);
+ auto d = data::Int::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eLong:
+ {
+ auto t = type::Long::DynamicCastAndCheck(type);
+ auto d = data::Long::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eFloat:
+ {
+ auto t = type::Float::DynamicCastAndCheck(type);
+ auto d = data::Float::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eDouble:
+ {
+ auto t = type::Double::DynamicCastAndCheck(type);
+ auto d = data::Double::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eString:
+ {
+ auto t = type::String::DynamicCastAndCheck(type);
+ auto d = data::String::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eBool:
+ {
+ auto t = type::Bool::DynamicCastAndCheck(type);
+ auto d = data::Bool::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eTime:
+ {
+ auto t = type::Time::DynamicCastAndCheck(type);
+ auto d = data::Long::DynamicCastAndCheck(data);
+ initializeRandomly(d, *t);
+ break;
+ }
+ case type::Descriptor::eUnknown:
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "No valid type found!");
+ }
+ }
+
+ }
+
+ void initializeRandomly(data::DictPtr& data, const type::Object& type, bool use_existing_data = true) const
+ {
+ for (auto& [key, nextData] : data->getElements())
+ {
+ initializeRandomly(nextData, type.getMemberTypes()[key], use_existing_data);
+ data->removeElement(key);
+ data->addElement(key, nextData);
+ }
+ }
+
+ void initializeRandomly(data::DictPtr& data, const type::Dict& type, bool use_existing_data = true) const
+ {
+ data->clear();
+ int numElements = util::generateRandom(5, 1);
+ std::set<std::string> usedKeys;
+ for (int i = 0; i < numElements; ++i)
+ {
+ std::string key = util::generateRandomWord(usedKeys);
+ usedKeys.insert(key);
+ data::VariantPtr newData = generateEmptyAronDataFromType(type.getAcceptedType());
+ initializeRandomly(newData, type.getAcceptedType(), use_existing_data);
+ data->addElement(key, newData);
+ }
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::Tuple& type, bool use_existing_data = true) const
+ {
+ std::vector<data::VariantPtr> newElements;
+
+ unsigned int i = 0;
+ for (auto& nextData : data->getElements())
+ {
+ initializeRandomly(nextData, type.getAcceptedType(i++), use_existing_data);
+ newElements.push_back(nextData);
+ }
+
+ data->clear();
+ for (const auto& el : newElements)
+ {
+ data->addElement(el);
+ }
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::Pair& type, bool use_existing_data = true) const
+ {
+ data::VariantPtr first = data->getElement(0);
+ data::VariantPtr second = data->getElement(1);
+ initializeRandomly(first, type.getFirstAcceptedType(), use_existing_data);
+ initializeRandomly(second, type.getSecondAcceptedType(), use_existing_data);
+
+ data->clear();
+ data->addElement(first);
+ data->addElement(second);
+ }
+
+ void initializeRandomly(data::ListPtr& data, const type::List& type, bool use_existing_data = true) const
+ {
+ data->clear();
+ int numElements = util::generateRandom(5, 1);
+ for (int i = 0; i < numElements; ++i)
+ {
+ data::VariantPtr newData = generateEmptyAronDataFromType(type.getAcceptedType());
+ initializeRandomly(newData, type.getAcceptedType(), use_existing_data);
+ data->addElement(newData);
+ }
+ }
+
+ void initializeRandomly(data::NDArrayPtr& data, const type::Variant& type) const
+ {
+ std::vector<int> dims = data->getShape();
+ if (!dims.empty())
+ {
+ int bytes = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>());
+ std::vector<unsigned char> blob = util::generateRandomBlob(bytes);
+ data->setData(bytes, blob.data());
+ }
+ }
+
+ void initializeRandomly(data::IntPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::LongPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::FloatPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::DoublePtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandom(1000, -1000));
+ }
+
+ void initializeRandomly(data::BoolPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::fiftyPercentChance());
+ }
+
+ void initializeRandomly(data::StringPtr& data, const type::Variant& type) const
+ {
+ data->setValue(util::generateRandomWord());
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/BaseClassTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/BaseClassTest.xml
index 089b6fdfe8b56088c2b74ce2afd7717933cd7fc8..af8a3451cf2f62c71a7561b0b23cef18b43a9fce 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/BaseClassTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/BaseClassTest.xml
@@ -2,6 +2,12 @@
<?xml version="1.0" encoding="UTF-8" ?>
<AronTypeDefinition>
<GenerateTypes>
+ <Object name="InnerClass">
+ <ObjectChild key="inner_class_member">
+ <Bool />
+ </ObjectChild>
+ </Object>
+
<Object name='armarx::BaseClassTest' doc-brief="A base class for the tests" doc-author="fabian.peller-konrad@kit.edu">
<ObjectChild key='base_class_member1' doc-brief="This is a a fancy bool. Only set this if needed...">
<Bool />
@@ -14,11 +20,7 @@
</ObjectChild>
<ObjectChild key='base_class_member3'>
- <Object name="InnerClass">
- <ObjectChild key="inner_class_member">
- <Bool />
- </ObjectChild>
- </Object>
+ <InnerClass />
</ObjectChild>
</Object>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/IVTCByteImageTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/IVTCByteImageTest.xml
deleted file mode 100644
index 38ac4391e6a51647ac9f43529f9543303bdbced1..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/test/aron/IVTCByteImageTest.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<AronTypeDefinition>
- <CodeIncludes>
- <Include include="<Image/ByteImage.h>" />
- </CodeIncludes>
- <GenerateTypes>
- <Object name='armarx::IVTCByteImageTest'>
-
- <ObjectChild key='the_grayscale_image'>
- <IVTCByteImage width="25" height="25" type="GrayScale" shared_ptr="ja" />
- </ObjectChild>
-
- <ObjectChild key='the_rgb_image'>
- <IVTCByteImage width="1920" height="1080" type="RGB24" shared_ptr="ja" />
- </ObjectChild>
-
- </Object>
- </GenerateTypes>
-</AronTypeDefinition>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/ImageTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/ImageTest.xml
index ab88fd71efc2e0e654296c734fdcb07d0eef7b12..f53a4f853481763806d75ffd0ababee22cd8561f 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/ImageTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/ImageTest.xml
@@ -8,11 +8,11 @@
<Object name='armarx::ImageTest'>
<ObjectChild key='the_rgb24_image'>
- <Image pixelType="rgb24" />
+ <Image type="rgb24" />
</ObjectChild>
<ObjectChild key='the_depth32_image'>
- <Image pixelType="depth32" />
+ <Image type="depth32" />
</ObjectChild>
</Object>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/ListTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/ListTest.xml
index 1c8ed164015d99ad0b5eddc8881dc4d43d626c28..1cde35422162d4d3e3d3387cabbe3d8845343113 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/ListTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/ListTest.xml
@@ -2,6 +2,18 @@
<?xml version="1.0" encoding="UTF-8" ?>
<AronTypeDefinition>
<GenerateTypes>
+ <Object name='ListClass'>
+ <ObjectChild key='element0'>
+ <Bool />
+ </ObjectChild>
+ <ObjectChild key='element1'>
+ <Int />
+ </ObjectChild>
+ <ObjectChild key='element2'>
+ <Double />
+ </ObjectChild>
+ </Object>
+
<Object name='armarx::ListTest'>
<ObjectChild key='floatList'>
<List>
@@ -40,17 +52,7 @@
</ObjectChild>
<ObjectChild key='objectList'>
<List>
- <Object name='ListClass'>
- <ObjectChild key='element0'>
- <Bool />
- </ObjectChild>
- <ObjectChild key='element1'>
- <Int />
- </ObjectChild>
- <ObjectChild key='element2'>
- <Double />
- </ObjectChild>
- </Object>
+ <ListClass />
</List>
</ObjectChild>
</Object>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/EigenMatrixTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/MatrixTest.xml
similarity index 70%
rename from source/RobotAPI/libraries/aron/core/test/aron/EigenMatrixTest.xml
rename to source/RobotAPI/libraries/aron/core/test/aron/MatrixTest.xml
index 59e994015fda4f1359f74c6cc6ac401cbb4f66fd..7d24f84484d491997eb1b96002276e47336194d3 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/EigenMatrixTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/MatrixTest.xml
@@ -9,19 +9,19 @@
<GenerateTypes>
<Object name='armarx::EigenMatrixTest'>
<ObjectChild key='the_short_eigen_matrix'>
- <EigenMatrix rows="5" cols="7" type="short" />
+ <Matrix rows="5" cols="7" type="int16" />
</ObjectChild>
<ObjectChild key='the_int_eigen_matrix'>
- <EigenMatrix rows="7" cols="7" type="int" />
+ <Matrix rows="7" cols="7" type="int32" />
</ObjectChild>
<ObjectChild key='the_long_eigen_matrix'>
- <EigenMatrix rows="7" cols="5" type="long" />
+ <Matrix rows="7" cols="5" type="int64" />
</ObjectChild>
<ObjectChild key='the_float_eigen_matrix'>
- <EigenMatrix rows="1" cols="9" type="float" />
+ <Matrix rows="1" cols="9" type="float32" />
</ObjectChild>
<ObjectChild key='the_double_eigen_matrix'>
- <EigenMatrix rows="25" cols="1" type="double" />
+ <Matrix rows="5" cols="1" type="float64" />
</ObjectChild>
</Object>
</GenerateTypes>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/ObjectTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/ObjectTest.xml
index 43903d1ce67236c564145ef79ed2732ff4fb522c..d0b514701e3d6647becf3ea469c13fbf349dcd3f 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/ObjectTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/ObjectTest.xml
@@ -9,26 +9,30 @@
</objectchild>
</Object>
+ <object name='LocalObjectTest1'>
+ <objectchild key='the_bool'>
+ <bool />
+ </objectchild>
+ <objectchild key='the_int'>
+ <int />
+ </objectchild>
+ </object>
+
+ <object name='LocalObjectTest2'>
+ <objectchild key='the_bool'>
+ <bool />
+ </objectchild>
+ <objectchild key='the_int'>
+ <int />
+ </objectchild>
+ </object>
+
<Object name='armarx::ObjectTest2'>
<objectchild key='local_object'>
- <object name='LocalObjectTest1'>
- <objectchild key='the_bool'>
- <bool />
- </objectchild>
- <objectchild key='the_int'>
- <int />
- </objectchild>
- </object>
+ <LocalObjectTest1 />
</ObjectChild>
<objectchild key='another_local_object'>
- <object name='LocalObjectTest2'>
- <objectchild key='the_bool'>
- <bool />
- </objectchild>
- <objectchild key='the_int'>
- <int />
- </objectchild>
- </object>
+ <LocalObjectTest2 />
</ObjectChild>
</Object>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/OpenCVMatTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/OpenCVMatTest.xml
deleted file mode 100644
index 1eb67f338db680eb65aa3e8c2bf25e9229f4b0fa..0000000000000000000000000000000000000000
--- a/source/RobotAPI/libraries/aron/core/test/aron/OpenCVMatTest.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<!--Some fancy comment -->
-<?xml version="1.0" encoding="UTF-8" ?>
-<AronTypeDefinition>
- <CodeIncludes>
- <Include include="<opencv2/core/core.hpp>" />
- </CodeIncludes>
- <GenerateTypes>
- <Object name='armarx::OpenCVMatTest'>
-
- <ObjectChild key='the_rgb24_image'>
- <Image pixelType="rgb24" />
- </ObjectChild>
-
- <ObjectChild key='the_depth32_image'>
- <Image pixelType="depth32" />
- </ObjectChild>
-
- <!--ObjectChild key='the_2d_opencv_matrix'>
- <OpenCVMat shape="25, 25" type="64F" />
- </ObjectChild>
- <ObjectChild key='the_3d_opencv_matrix'>
- <OpenCVMat shape="25, 25, 25" type="CV_32F" />
- </ObjectChild>
- <ObjectChild key='the_4d_opencv_matrix'>
- <OpenCVMat shape="25, 25, 25, 25" type="CV_32S" />
- </ObjectChild>
- <ObjectChild key='the_5d_opencv_matrix'>
- <OpenCVMat shape="25, 25, 25, 25, 25" type="16U" />
- </ObjectChild-->
- </Object>
- </GenerateTypes>
-</AronTypeDefinition>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/OptionalTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/OptionalTest.xml
index 7b402cb38e4b904723c31ce7097ebc7623c296ba..332e9b13e489cb6426cb9a0a88aa238d8aaea9d3 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/OptionalTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/OptionalTest.xml
@@ -9,10 +9,12 @@
<Float />
</ObjectChild>
</Object>
+
+
<Object name='armarx::OptionalTest'>
<ObjectChild key='some_float'>
- <Float optional="1"/>
+ <Float optional="true"/>
</ObjectChild>
<ObjectChild key='some_string'>
@@ -20,7 +22,7 @@
</ObjectChild>
<ObjectChild key='some_dict'>
- <Dict optional="wahr">
+ <Dict optional="true">
<Float />
</Dict>
</ObjectChild>
@@ -32,7 +34,7 @@
</ObjectChild>
<ObjectChild key='some_list'>
- <List optional="ja">
+ <List optional="true">
<Double />
</List>
</ObjectChild>
@@ -44,17 +46,17 @@
</ObjectChild>
<ObjectChild key='some_eigen_matrix'>
- <EigenMatrix rows="25" cols="10" type="long" optional="ja"/>
+ <Matrix rows="25" cols="10" type="int64" optional="true"/>
</ObjectChild>
<ObjectChild key='some_obj'>
- <armarx::OptionalTestElement optional="ja"/>
+ <armarx::OptionalTestElement optional="true"/>
</ObjectChild>
<ObjectChild key='some_list_with_optional_list'>
- <List optional="ja">
- <List optional="ja">
- <Float optional="ja" />
+ <List optional="true">
+ <List optional="true">
+ <Float optional="true" />
</List>
</List>
</ObjectChild>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/PCLPointCloudTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/PointCloudTest.xml
similarity index 77%
rename from source/RobotAPI/libraries/aron/core/test/aron/PCLPointCloudTest.xml
rename to source/RobotAPI/libraries/aron/core/test/aron/PointCloudTest.xml
index dff170ce43a968424e05839de91ada689e49ecf1..3387de7bcce7ddf97ee9f91df6702abd876c067e 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/PCLPointCloudTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/PointCloudTest.xml
@@ -10,10 +10,11 @@
<GenerateTypes>
<Object name='armarx::PointCloudTest'>
<ObjectChild key='the_xyzrgb_pcl_pointcloud'>
- <PCLPointCloud width="25" height="25" type="PointXYZRGB" />
+ <PointCloud type="PointXYZRGB" />
</ObjectChild>
+
<ObjectChild key='the_xyzrgba_pcl_pointcloud'>
- <PCLPointCloud width="128" height="128" type="pcl::PointXYZRGBA" />
+ <PointCloud type="PointXYZRGBA" />
</ObjectChild>
</Object>
</GenerateTypes>
diff --git a/source/RobotAPI/libraries/aron/core/test/aron/EigenQuaternionTest.xml b/source/RobotAPI/libraries/aron/core/test/aron/QuaternionTest.xml
similarity index 83%
rename from source/RobotAPI/libraries/aron/core/test/aron/EigenQuaternionTest.xml
rename to source/RobotAPI/libraries/aron/core/test/aron/QuaternionTest.xml
index cc175020464ffa683fe102c0fc93a7c27011c34a..a5f2522e2efa683a3c72075f058460fca4d92fae 100644
--- a/source/RobotAPI/libraries/aron/core/test/aron/EigenQuaternionTest.xml
+++ b/source/RobotAPI/libraries/aron/core/test/aron/QuaternionTest.xml
@@ -11,11 +11,11 @@
<Object name='armarx::EigenQuaternionTest'>
<ObjectChild key='the_float_quaternion'>
- <EigenQuaternion type="float" />
+ <Quaternion type="float32" />
</ObjectChild>
<ObjectChild key='the_double_quaternion'>
- <EigenQuaternion type="double" />
+ <Quaternion type="float64" />
</ObjectChild>
</Object>
diff --git a/source/RobotAPI/libraries/aron/core/test/aronCodeGenerationTest.cpp b/source/RobotAPI/libraries/aron/core/test/aronCodeGenerationTest.cpp
index 44bbb19a9bad2cb37d6ba4fc9305a0f4bb05f979..592c50a0e54b9bab438b85f8da9a4c8cc1a01464 100644
--- a/source/RobotAPI/libraries/aron/core/test/aronCodeGenerationTest.cpp
+++ b/source/RobotAPI/libraries/aron/core/test/aronCodeGenerationTest.cpp
@@ -39,8 +39,7 @@
#include <RobotAPI/libraries/aron/core/Exception.h>
// Aron
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/Randomizer.h>
+#include <RobotAPI/libraries/aron/core/test/Randomizer.h>
// Generated File
#include <RobotAPI/libraries/aron/core/test/aron/ListTest.aron.generated.h>
@@ -48,11 +47,9 @@
#include <RobotAPI/libraries/aron/core/test/aron/PrimitiveTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/ObjectTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/ImageTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/IVTCByteImageTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/EigenMatrixTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/EigenQuaternionTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/OpenCVMatTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/PCLPointCloudTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/MatrixTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/QuaternionTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/PointCloudTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/PositionTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/OrientationTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/PoseTest.aron.generated.h>
@@ -178,7 +175,7 @@ BOOST_AUTO_TEST_CASE(AronCodeGenerationPrimitiveTest)
BOOST_AUTO_TEST_CASE(AronCodeGenerationOptionalTest)
{
- std::cout << "Running Code Gen Primitive test" << std::endl;
+ std::cout << "Running Code Gen Optional test" << std::endl;
OptionalTest p_tmp;
OptionalTest p = p_tmp; // test assignment
BOOST_CHECK_EQUAL(p_tmp == p, true);
@@ -204,7 +201,6 @@ BOOST_AUTO_TEST_CASE(AronCodeGenerationOptionalTest)
p.some_float = 5.0f;
BOOST_CHECK_EQUAL(p.some_float.has_value() == true, true);
aron = p.toAron();
- BOOST_CHECK_EQUAL(*aron->getElement("some_float") == std::make_shared<datanavigator::FloatNavigator>(5.0f), true);
+ BOOST_CHECK_EQUAL(*aron->getElement("some_float") == std::make_shared<armarx::aron::data::Float>(5.0f), true);
BOOST_CHECK_EQUAL(*aron->getElement("some_float") == nullptr, false);
-
}
diff --git a/source/RobotAPI/libraries/aron/core/test/aronExtendsTest.cpp b/source/RobotAPI/libraries/aron/core/test/aronExtendsTest.cpp
index 4cef5c63fa14fcee4121851458802ddd0338bb77..d6dd46a4d9e3599fbb1b4b0c89dfe7e3b3a167a2 100644
--- a/source/RobotAPI/libraries/aron/core/test/aronExtendsTest.cpp
+++ b/source/RobotAPI/libraries/aron/core/test/aronExtendsTest.cpp
@@ -39,8 +39,7 @@
#include <RobotAPI/libraries/aron/core/Exception.h>
// Aron
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
// Generated File
#include <RobotAPI/libraries/aron/core/test/aron/BaseClassTest.aron.generated.h>
diff --git a/source/RobotAPI/libraries/aron/core/test/aronNavigateTest.cpp b/source/RobotAPI/libraries/aron/core/test/aronNavigateTest.cpp
index 70adfc5e7647f7a4118d750ca060c5804ae8d84a..ebc491ef2edf3827ae6749a2ee8f8c14f60abe8d 100644
--- a/source/RobotAPI/libraries/aron/core/test/aronNavigateTest.cpp
+++ b/source/RobotAPI/libraries/aron/core/test/aronNavigateTest.cpp
@@ -39,8 +39,7 @@
#include <RobotAPI/libraries/aron/core/Exception.h>
// Aron
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/Randomizer.h>
+#include <RobotAPI/libraries/aron/core/test/Randomizer.h>
// Generated File
#include <RobotAPI/libraries/aron/core/test/aron/NaturalIKTest.aron.generated.h>
@@ -55,7 +54,7 @@ BOOST_AUTO_TEST_CASE(AronNavigateTest)
NaturalIKResult k2;
// test Path
- datanavigator::DictNavigatorPtr aron = k.toAron();
+ data::DictPtr aron = k.toAron();
Path path = aron->getPath(); // should be empty since aron is top level object
Path memberReached(path, "reached");
Path memberJointValues(path, "jointValues");
@@ -77,16 +76,16 @@ BOOST_AUTO_TEST_CASE(AronNavigateTest)
BOOST_CHECK_EQUAL(indexJointValues1.toString(), "\\->jointValues->1");
BOOST_CHECK_EQUAL(indexJointValues1.size(), 2);
- datanavigator::BoolNavigatorPtr reached = datanavigator::BoolNavigator::DynamicCastAndCheck(aron->navigateAbsolute(memberReached));
- datanavigator::ListNavigatorPtr jointValues = datanavigator::ListNavigator::DynamicCastAndCheck(aron->navigateAbsolute(memberJointValues));
+ data::BoolPtr reached = data::Bool::DynamicCastAndCheck(aron->navigateAbsolute(memberReached));
+ data::ListPtr jointValues = data::List::DynamicCastAndCheck(aron->navigateAbsolute(memberJointValues));
if (jointValues->childrenSize() > 0)
{
- datanavigator::FloatNavigatorPtr el = datanavigator::FloatNavigator::DynamicCastAndCheck(aron->navigateAbsolute(indexJointValues0));
+ data::FloatPtr el = data::Float::DynamicCastAndCheck(aron->navigateAbsolute(indexJointValues0));
}
if (jointValues->childrenSize() > 1)
{
- datanavigator::FloatNavigatorPtr el = datanavigator::FloatNavigator::DynamicCastAndCheck(aron->navigateAbsolute(indexJointValues1));
+ data::FloatPtr el = data::Float::DynamicCastAndCheck(aron->navigateAbsolute(indexJointValues1));
}
Path diff = indexJointValues1.getWithoutPrefix(indexJointValues0);
diff --git a/source/RobotAPI/libraries/aron/core/test/aronOperatorTest.cpp b/source/RobotAPI/libraries/aron/core/test/aronOperatorTest.cpp
index 6c1e44fdb6c6164c74dbe73ab067f0526dea7317..3594ba89ddfc6942694c53b54a3ddfaecf6f4a26 100644
--- a/source/RobotAPI/libraries/aron/core/test/aronOperatorTest.cpp
+++ b/source/RobotAPI/libraries/aron/core/test/aronOperatorTest.cpp
@@ -39,8 +39,7 @@
#include <RobotAPI/libraries/aron/core/Exception.h>
// Aron
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/navigator/data/AllNavigators.h>
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
using namespace armarx;
using namespace aron;
@@ -55,12 +54,12 @@ BOOST_AUTO_TEST_CASE(AronAssignmentTest)
std::string s = "Hello World";
bool b = true;
- aron::datanavigator::FloatNavigator fn = f;
- aron::datanavigator::DoubleNavigator dn = d;
- aron::datanavigator::IntNavigator in = i;
- aron::datanavigator::LongNavigator ln = l;
- aron::datanavigator::StringNavigator sn = s;
- aron::datanavigator::BoolNavigator bn = b;
+ aron::data::Float fn = f;
+ aron::data::Double dn = d;
+ aron::data::Int in = i;
+ aron::data::Long ln = l;
+ aron::data::String sn = s;
+ aron::data::Bool bn = b;
BOOST_CHECK_EQUAL((float) fn == f, true);
BOOST_CHECK_EQUAL((double) dn == d, true);
@@ -73,15 +72,15 @@ BOOST_AUTO_TEST_CASE(AronAssignmentTest)
BOOST_AUTO_TEST_CASE(AronEqualsTest)
{
std::cout << "Aron equals test" << std::endl;
- aron::datanavigator::FloatNavigator fn = 5.0;
- aron::datanavigator::FloatNavigator fn_equals = 5.0;
- aron::datanavigator::FloatNavigator fn_unequals = 6.0;
+ aron::data::Float fn = 5.0;
+ aron::data::Float fn_equals = 5.0;
+ aron::data::Float fn_unequals = 6.0;
BOOST_CHECK_EQUAL(fn == fn_equals, true);
BOOST_CHECK_EQUAL(fn == fn_unequals, false);
- auto fn_ptr_equals = std::make_shared<aron::datanavigator::FloatNavigator>(5.0);
- auto fn_ptr_unequals = std::make_shared<aron::datanavigator::FloatNavigator>(42.0);
+ auto fn_ptr_equals = std::make_shared<aron::data::Float>(5.0);
+ auto fn_ptr_unequals = std::make_shared<aron::data::Float>(42.0);
BOOST_CHECK_EQUAL(fn == fn_ptr_equals, true);
BOOST_CHECK_EQUAL(fn == fn_ptr_unequals, false);
diff --git a/source/RobotAPI/libraries/aron/core/test/aronRandomizedTest.cpp b/source/RobotAPI/libraries/aron/core/test/aronRandomizedTest.cpp
index b9c54acda1e8d0e1b70477427a2d8c848bbedb15..77a9ad525476d265e7919cf112abf761552670dd 100644
--- a/source/RobotAPI/libraries/aron/core/test/aronRandomizedTest.cpp
+++ b/source/RobotAPI/libraries/aron/core/test/aronRandomizedTest.cpp
@@ -31,11 +31,9 @@
#include <RobotAPI/libraries/aron/core/test/aron/PrimitiveTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/ObjectTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/ImageTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/IVTCByteImageTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/EigenMatrixTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/EigenQuaternionTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/OpenCVMatTest.aron.generated.h>
-#include <RobotAPI/libraries/aron/core/test/aron/PCLPointCloudTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/MatrixTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/QuaternionTest.aron.generated.h>
+#include <RobotAPI/libraries/aron/core/test/aron/PointCloudTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/PositionTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/OrientationTest.aron.generated.h>
#include <RobotAPI/libraries/aron/core/test/aron/PoseTest.aron.generated.h>
@@ -43,26 +41,27 @@
#include <RobotAPI/libraries/aron/core/test/aron/OptionalTest.aron.generated.h>
// Aron
-#include <RobotAPI/libraries/aron/core/Debug.h>
-#include <RobotAPI/libraries/aron/core/Randomizer.h>
+#include <RobotAPI/libraries/aron/core/test/Randomizer.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/navigator/NavigatorReader.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/reader/nlohmannJSON/NlohmannJSONReader.h>
+#include <RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>
+#include <RobotAPI/libraries/aron/core/data/rw/reader/nlohmannJSON/NlohmannJSONReader.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/navigator/NavigatorWriter.h>
-#include <RobotAPI/libraries/aron/core/io/dataIO/writer/nlohmannJSON/NlohmannJSONWriter.h>
+#include <RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>
+#include <RobotAPI/libraries/aron/core/data/rw/writer/nlohmannJSON/NlohmannJSONWriter.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/navigator/NavigatorReader.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/reader/nlohmannJSON/NlohmannJSONReader.h>
+#include <RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.h>
+#include <RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/navigator/NavigatorWriter.h>
-#include <RobotAPI/libraries/aron/core/io/typeIO/writer/nlohmannJSON/NlohmannJSONWriter.h>
+#include <RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>
+#include <RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.h>
+#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
// ArmarX
#include <ArmarXCore/libraries/cppgen/CppMethod.h>
#include <ArmarXCore/libraries/cppgen/CppClass.h>
#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
// IVT
@@ -106,27 +105,26 @@ void test_toAronType(T& in, T& out)
BOOST_TEST_CONTEXT("getting in type")
{
- typenavigator::ObjectNavigatorPtr in_type_nav = in.toAronType();
+ type::ObjectPtr in_type_nav = in.toAronType();
- type::AronObjectPtr in_type = in_type_nav->toAronObjectPtr();
+ type::dto::AronObjectPtr in_type = in_type_nav->toObjectDTO();
BOOST_CHECK(in_type);
- armarx::aron::typeIO::writer::NlohmannJSONWriter json_writer_in;
- in.writeType(json_writer_in);
- in_type_json = json_writer_in.getResult();
+ armarx::aron::type::writer::NlohmannJSONWriter json_writer_in;
+ in_type_json = in.writeType(json_writer_in);
+
BOOST_CHECK(in_type_json.is_object());
}
BOOST_TEST_CONTEXT("getting out type")
{
- typenavigator::ObjectNavigatorPtr out_type_nav = out.toAronType();
+ type::ObjectPtr out_type_nav = out.toAronType();
- type::AronObjectPtr out_type = out_type_nav->toAronObjectPtr();
+ type::dto::AronObjectPtr out_type = out_type_nav->toObjectDTO();
BOOST_CHECK(out_type);
- armarx::aron::typeIO::writer::NlohmannJSONWriter json_writer_out;
- out.writeType(json_writer_out);
- out_type_json = json_writer_out.getResult();
+ armarx::aron::type::writer::NlohmannJSONWriter json_writer_out;
+ out_type_json = out.writeType(json_writer_out);
BOOST_CHECK(out_type_json.is_object());
}
@@ -139,110 +137,114 @@ void test_toAronType(T& in, T& out)
template <typename T>
void test_toAron(T& in, T& out)
{
- datanavigator::DictNavigatorPtr in_aron_nav = in.toAron();
Randomizer r;
+ data::DictPtr in_aron_nav = in.toAron();
BOOST_TEST_CONTEXT("initialize in aron randomly")
{
- typenavigator::ObjectNavigatorPtr in_type_nav = in.toAronType();
- r.initializeRandomly(in_aron_nav, in_type_nav);
+ type::ObjectPtr in_type_nav = in.toAronType();
+ r.initializeRandomly(in_aron_nav, *in_type_nav);
}
BOOST_TEST_INFO("getting in aron");
- data::AronDictPtr in_aron = in_aron_nav->toAronDictPtr();
+ data::dto::DictPtr in_aron = in_aron_nav->toAronDictPtr();
BOOST_CHECK(in_aron);
- BOOST_TEST_MESSAGE("in aron: \n" << armarx::aron::Debug::AronDataPtrToString(in_aron));
- BOOST_TEST_MESSAGE("out aron: \n" << armarx::aron::Debug::AronDataPtrToString(out.toAron()->toAronDictPtr()));
+ //BOOST_TEST_MESSAGE("in_aron_nav: \n" << converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(in_aron_nav).dump(2));
+ //BOOST_TEST_MESSAGE("out.toAron(): \n" << converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(out.toAron()).dump(2));
- datanavigator::DictNavigatorPtr out_aron_nav;
+ data::DictPtr out_aron_nav;
BOOST_TEST_CONTEXT("setting out aron from in aron")
{
- out.fromAron(in_aron);
+ out.fromAron(in_aron_nav);
BOOST_TEST_INFO("getting out aron");
out_aron_nav = out.toAron();
BOOST_CHECK(*in_aron_nav == *out_aron_nav);
- data::AronDictPtr out_aron = out_aron_nav->toAronDictPtr();
+ data::dto::DictPtr out_aron = out_aron_nav->toAronDictPtr();
BOOST_CHECK(out_aron);
}
BOOST_TEST_CONTEXT("setting in aron from out aron and check for equality")
{
in.fromAron(out_aron_nav);
-
- BOOST_TEST_MESSAGE("in Aron: \n" << armarx::aron::Debug::AronDataPtrToString(in.toAron()->toAronDictPtr()));
- BOOST_TEST_MESSAGE("out Aron: \n" << armarx::aron::Debug::AronDataPtrToString(out.toAron()->toAronDictPtr()));
BOOST_CHECK(in == out);
- datanavigator::DictNavigatorPtr in_aron_nav_again = in.toAron();
+ data::DictPtr in_aron_nav_again = in.toAron();
+ BOOST_TEST_MESSAGE("in_aron_nav: \n" << converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(in_aron_nav).dump(2));
+ BOOST_TEST_MESSAGE("in_aron_nav_again: \n" << converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(in_aron_nav_again).dump(2));
+
BOOST_CHECK(*in_aron_nav == *in_aron_nav_again);
}
}
-
+#if 0
template <typename T>
void test_toJson(T& in, T& out)
{
- datanavigator::DictNavigatorPtr in_aron_nav = in.toAron();
-
Randomizer r;
+
+ data::DictPtr in_aron_nav = in.toAron();
{
- typenavigator::ObjectNavigatorPtr in_type_nav = in.toAronType();
- r.initializeRandomly(in_aron_nav, in_type_nav);
+ type::ObjectPtr in_type_nav = in.toAronType();
+ r.initializeRandomly(in_aron_nav, *in_type_nav);
}
- data::AronDictPtr in_aron = in_aron_nav->toAronDictPtr();
- in.fromAron(in_aron);
-
- armarx::aron::dataIO::writer::NlohmannJSONWriter json_writer_for_in;
- armarx::aron::dataIO::writer::NlohmannJSONWriter json_writer_for_out;
+ data::dto::DictPtr in_aron = in_aron_nav->toAronDictPtr();
+ in.fromAron(in_aron_nav);
nlohmann::json in_aron_json;
std::string in_aron_json_str;
- BOOST_TEST_CONTEXT("check JSON export of k and out for equality")
+ BOOST_TEST_CONTEXT("check JSON export of in and visitor implementation for equality")
{
- in.write(json_writer_for_in);
- in_aron_json = json_writer_for_in.getResult();
+ in_aron_json = in.toJSON();
in_aron_json_str = in_aron_json.dump(4);
- armarx::aron::dataIO::writer::NlohmannJSONWriter direct_json_writer_for_in;
- armarx::aron::dataIO::Visitor::VisitAndSetup(direct_json_writer_for_in, in_aron);
- nlohmann::json direct_in_aron_json = direct_json_writer_for_in.getResult();
+ nlohmann::json direct_in_aron_json = converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(in_aron_nav);
std::string direct_in_aron_json_str = direct_in_aron_json.dump(4);
- BOOST_TEST_CONTEXT( "\n> in as json: \n" << in_aron_json_str
- << "\n> n as direct json: \n" << direct_in_aron_json_str)
- {
- BOOST_CHECK(in_aron_json_str == direct_in_aron_json_str);
- }
+ BOOST_TEST_MESSAGE("in toJSON: \n" << in_aron_json_str);
+ BOOST_TEST_MESSAGE("in JSON Converter: \n" << direct_in_aron_json_str);
+ BOOST_CHECK(in_aron_json_str == direct_in_aron_json_str);
}
- armarx::aron::dataIO::reader::NlohmannJSONReader json_reader_for_out(in_aron_json);
+ nlohmann::json out_aron_json;
+ std::string out_aron_json_str;
+ BOOST_TEST_CONTEXT("setting out from in json and check JSON export of out and visitor implementation for equality")
+ {
+ out.fromJSON(in_aron_json);
+ data::DictPtr out_aron_nav = out.toAron();
+ out_aron_json = out.toJSON();
+ out_aron_json_str = out_aron_json.dump(4);
- out.read(json_reader_for_out);
- out.write(json_writer_for_out);
+ nlohmann::json direct_out_aron_json = converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(out_aron_nav);
+ std::string direct_out_aron_json_str = direct_out_aron_json.dump(4);
- nlohmann::json out_aron_json = json_writer_for_out.getResult();
- std::string out_aron_json_str = out_aron_json.dump(4);
+ BOOST_TEST_MESSAGE("out toJSON: \n" << out_aron_json_str);
+ BOOST_TEST_MESSAGE("out JSON Converter: \n" << direct_out_aron_json_str);
+ }
- BOOST_TEST_CONTEXT( "\n> in as json: \n" << in_aron_json_str
- << "\n> out as json: \n" << out_aron_json_str)
+
+ BOOST_TEST_CONTEXT("checking in and out json for equality")
{
+ BOOST_TEST_MESSAGE("in_aron_json_str: \n" << in_aron_json_str);
+ BOOST_TEST_MESSAGE("out_aron_json_str: \n" << out_aron_json_str);
BOOST_CHECK(in_aron_json_str == out_aron_json_str);
}
}
+#endif
template <typename T>
void runTestWithInstances(T& in, T& out)
{
// assumes not nullptrs as in and out. If you have a maybe type then make sure that it is set properly
-
test_toAronType(in, out);
test_toAron(in, out);
+#if 0
test_toJson(in, out);
+#endif
}
@@ -282,30 +284,9 @@ BOOST_AUTO_TEST_CASE(test_Object)
runTestWithInstances<ObjectTest2>(o2, o22);
}
-BOOST_AUTO_TEST_CASE(test_IVTCByteImage)
-{
- BOOST_TEST_MESSAGE("Running Image test");
- IVTCByteImageTest ii;
- IVTCByteImageTest ii2;
-
- ii.the_grayscale_image = std::make_shared<CByteImage>();
- ii2.the_grayscale_image = std::make_shared<CByteImage>();
-
- ii.the_rgb_image = std::make_shared<CByteImage>();
- ii2.the_rgb_image = std::make_shared<CByteImage>();
-
- ii.the_grayscale_image->Set(5, 5, CByteImage::eGrayScale);
- ii2.the_grayscale_image->Set(7, 7, CByteImage::eGrayScale);
-
- ii.the_rgb_image->Set(5, 5, CByteImage::eRGB24);
- ii2.the_rgb_image->Set(7, 7, CByteImage::eRGB24);
-
- runTestWithInstances<IVTCByteImageTest>(ii, ii2);
-}
-
BOOST_AUTO_TEST_CASE(test_EigenMatrix)
{
- // Eigen may cause problems with dimensions > 145
+ // Eigen may cause problems with equality checks. Sometimes even with dimension ~25
BOOST_TEST_MESSAGE("Running EigenMatrix test");
EigenMatrixTest em;
EigenMatrixTest em2;
@@ -321,18 +302,18 @@ BOOST_AUTO_TEST_CASE(test_Image)
image.the_rgb24_image.create(3, 4, image.the_rgb24_image.type());
image.the_depth32_image.create(3, 4, image.the_depth32_image.type());
- /* Could be used for ndarray test
- image.the_2d_opencv_matrix = cv::Mat(2, 2, CV_64F);
- image.the_3d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2}), CV_32F);
- image.the_4d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2, 2}), CV_16S);
- image.the_5d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2, 2, 2}), CV_8U);
- */
+ // Could be used for ndarray test
+ //image.the_2d_opencv_matrix = cv::Mat(2, 2, CV_64F);
+ //image.the_3d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2}), CV_32F);
+ //image.the_4d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2, 2}), CV_16S);
+ //image.the_5d_opencv_matrix = cv::Mat(std::vector<int>({2, 2, 2, 2, 2}), CV_8U);
+
runTestWithInstances<ImageTest>(image, image2);
}
-BOOST_AUTO_TEST_CASE(test_PCLPointCloud)
+BOOST_AUTO_TEST_CASE(test_PointCloud)
{
- BOOST_TEST_MESSAGE("Running PCLPointCloud test");
+ BOOST_TEST_MESSAGE("Running PointCloud test");
PointCloudTest pc;
PointCloudTest pc2;
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/Reader.cpp b/source/RobotAPI/libraries/aron/core/type/rw/Reader.cpp
similarity index 100%
rename from source/RobotAPI/libraries/aron/core/io/typeIO/Reader.cpp
rename to source/RobotAPI/libraries/aron/core/type/rw/Reader.cpp
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/Reader.h b/source/RobotAPI/libraries/aron/core/type/rw/Reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..00dfea092a57c084da278f476b31a620cd90723d
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/Reader.h
@@ -0,0 +1,107 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The ReaderInterface class. It defines the interface to extract information from an aron representation
+ */
+ template <class InputType>
+ class ReaderInterface
+ {
+ public:
+
+ virtual ~ReaderInterface() = default;
+
+ /// Extract information from an Object type
+ virtual void readObject(const InputType& input, std::string& name, std::map<std::string, InputType>& memberTypes, type::Maybe& maybe) = 0;
+
+ /// Extract information from a list type
+ virtual void readList(const InputType& input, InputType& acceptedType, type::Maybe& maybe) = 0;
+
+ /// Extract information from a dict type
+ virtual void readDict(const InputType& input, InputType& acceptedType, type::Maybe& maybe) = 0;
+
+ /// Extract information from a tuple type
+ virtual void readTuple(const InputType& input, std::vector<InputType>& acceptedTypes, type::Maybe& maybe) = 0;
+
+ /// Extract information from a pair type
+ virtual void readPair(const InputType& input, std::pair<InputType, InputType>& acceptedTypes, type::Maybe& maybe) = 0;
+
+ /// Extract information from a ndarray type
+ virtual void readNDArray(const InputType& input, int& ndim, type::ndarray::ElementType& type, type::Maybe& maybe) = 0;
+
+ /// Extract information from a matrix type
+ virtual void readMatrix(const InputType& input, int& rows, int& cols, type::matrix::ElementType& type, type::Maybe& maybe) = 0;
+
+ /// Extract information from a quaternion type
+ virtual void readQuaternion(const InputType& input, type::quaternion::ElementType& type, type::Maybe& maybe) = 0;
+
+ /// Extract information from a pointcloud type
+ virtual void readPointCloud(const InputType& input, type::pointcloud::VoxelType& type, type::Maybe& maybe) = 0;
+
+ /// Extract information from an image type
+ virtual void readImage(const InputType& input, type::image::PixelType& type, type::Maybe& maybe) = 0;
+
+ /// Extract information from a position type
+ virtual void readPosition(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an orientation type
+ virtual void readOrientation(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from a pose type
+ virtual void readPose(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an int enum type
+ virtual void readIntEnum(const InputType& input, std::string& name, std::map<std::string, int>& acceptedValues, type::Maybe& maybe) = 0;
+
+ /// Extract information from an int type
+ virtual void readInt(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an long type
+ virtual void readLong(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an float type
+ virtual void readFloat(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an double type
+ virtual void readDouble(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an string type
+ virtual void readString(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an bool type
+ virtual void readBool(const InputType& input, type::Maybe& maybe) = 0;
+
+ /// Extract information from an time type
+ virtual void readTime(const InputType& input, type::Maybe& maybe) = 0;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/io/typeIO/Writer.cpp b/source/RobotAPI/libraries/aron/core/type/rw/Writer.cpp
similarity index 100%
rename from source/RobotAPI/libraries/aron/core/io/typeIO/Writer.cpp
rename to source/RobotAPI/libraries/aron/core/type/rw/Writer.cpp
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/Writer.h b/source/RobotAPI/libraries/aron/core/type/rw/Writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0f0620a491c120090be226712b5e1e8e9d55411
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/Writer.h
@@ -0,0 +1,107 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The WriterInterface class. It defines the interface to construct aron representations (e.g. variant or nlohmann::json)
+ */
+ template <class ReturnType>
+ class WriterInterface
+ {
+ public:
+
+ virtual ~WriterInterface() = default;
+
+ /// Construct an object from the params
+ virtual ReturnType writeObject(const std::string& name, const type::Maybe maybe, const std::map<std::string, ReturnType>& memberTypes, const std::optional<ReturnType>& extends) = 0;
+
+ /// Construct a list from the params
+ virtual ReturnType writeList(const type::Maybe maybe, const ReturnType& acceptedType) = 0;
+
+ /// Construct a dict from the params
+ virtual ReturnType writeDict(const type::Maybe maybe, const ReturnType& acceptedType) = 0;
+
+ /// Construct a pair from the params
+ virtual ReturnType writePair(const type::Maybe maybe, const ReturnType& acceptedType1, const ReturnType& acceptedType2) = 0;
+
+ /// Construct a tuple from the params
+ virtual ReturnType writeTuple(const type::Maybe maybe, const std::vector<ReturnType>& acceptedTypes) = 0;
+
+ /// Construct a ndarray from the params
+ virtual ReturnType writeNDArray(const int ndim, const type::ndarray::ElementType, const type::Maybe maybe) = 0;
+
+ /// Construct a matrix from the params
+ virtual ReturnType writeMatrix(const int rows, const int cols, const type::matrix::ElementType type, const type::Maybe maybe) = 0;
+
+ /// Construct a quaternion from the params
+ virtual ReturnType writeQuaternion(const type::quaternion::ElementType, const type::Maybe maybe) = 0;
+
+ /// Construct a image from the params
+ virtual ReturnType writeImage(const type::image::PixelType, const type::Maybe maybe) = 0;
+
+ /// Construct a pointcloud from the params
+ virtual ReturnType writePointCloud(const type::pointcloud::VoxelType, const type::Maybe maybe) = 0;
+
+ /// Construct a position from the params
+ virtual ReturnType writePosition(const type::Maybe maybe) = 0;
+
+ /// Construct a orientation from the params
+ virtual ReturnType writeOrientation(const type::Maybe maybe) = 0;
+
+ /// Construct a pose from the params
+ virtual ReturnType writePose(const type::Maybe maybe) = 0;
+
+ /// Construct a int enum from the params
+ virtual ReturnType writeIntEnum(const std::string& name, const std::map<std::string, int>& acceptedValues, const type::Maybe maybe) = 0;
+
+ /// Construct a int from the params
+ virtual ReturnType writeInt(const type::Maybe maybe) = 0;
+
+ /// Construct a long from the params
+ virtual ReturnType writeLong(const type::Maybe maybe) = 0;
+
+ /// Construct a float from the params
+ virtual ReturnType writeFloat(const type::Maybe maybe) = 0;
+
+ /// Construct a double from the params
+ virtual ReturnType writeDouble(const type::Maybe maybe) = 0;
+
+ /// Construct a string from the params
+ virtual ReturnType writeString(const type::Maybe maybe) = 0;
+
+ /// Construct a bool from the params
+ virtual ReturnType writeBool(const type::Maybe maybe) = 0;
+
+ /// Construct a time from the params
+ virtual ReturnType writeTime(const type::Maybe maybe) = 0;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/json/Data.h b/source/RobotAPI/libraries/aron/core/type/rw/json/Data.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4e84415be729077b554d5d26a47734f8d758300
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/json/Data.h
@@ -0,0 +1,162 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <string>
+
+// ArmarX
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+/**
+ * Constantes and conversion maps for the nlohmann::json representation (reader and writer)
+ */
+namespace armarx::aron::type::rw::json
+{
+ namespace constantes
+ {
+ const std::string MAYBE_SLUG = "_ARON_MAYBE";
+ const std::string TYPE_SLUG = "_ARON_TYPE";
+ const std::string VERSION_SLUG = "_ARON_VERSION";
+
+ const std::string KEY_SLUG = "_ARON_KEY";
+ const std::string VALUE_SLUG = "_ARON_VALUE";
+ const std::string MEMBERS_SLUG = "_ARON_MEMBERS";
+ const std::string ELEMENTS_SLUG = "_ARON_ELEMENTS";
+
+ const std::string NAME_SLUG = "_ARON_NAME";
+ const std::string EXTENDS_SLUG = "_ARON_EXTENDS";
+ const std::string ACCEPTED_TYPE_SLUG = "_ARON_ACCEPTED_TYPE";
+ const std::string DIMENSIONS_SLUG = "_ARON_DIMESIONS";
+ const std::string DATA_SLUG = "_ARON_DATA";
+ const std::string USED_TYPE_SLUG = "_ARON_USED_TYPE";
+
+ const std::string LIST_TYPENAME_SLUG = "_ARON_LIST";
+ const std::string DICT_TYPENAME_SLUG = "_ARON_DICT";
+ const std::string OBJECT_TYPENAME_SLUG = "_ARON_OBJECT";
+ const std::string TUPLE_TYPENAME_SLUG = "_ARON_TUPLE";
+ const std::string PAIR_TYPENAME_SLUG = "_ARON_PAIR";
+ const std::string NDARRAY_TYPENAME_SLUG = "_ARON_NDARRAY";
+ const std::string IMAGE_TYPENAME_SLUG = "_ARON_IMAGE";
+ const std::string MATRIX_TYPENAME_SLUG = "_ARON_MATRIX";
+ const std::string ORIENTATION_TYPENAME_SLUG = "_ARON_ORIENTATION";
+ const std::string POINT_CLOUD_TYPENAME_SLUG = "_ARON_POINT_CLOUD";
+ const std::string POSE_TYPENAME_SLUG = "_ARON_POSE";
+ const std::string POSITION_TYPENAME_SLUG = "_ARON_POSITION";
+ const std::string QUATERNION_TYPENAME_SLUG = "_ARON_QUATERNION";
+ const std::string INT_ENUM_TYPENAME_SLUG = "_ARON_INT_ENUM";
+ const std::string INT_TYPENAME_SLUG = "_ARON_INT";
+ const std::string LONG_TYPENAME_SLUG = "_ARON_LONG";
+ const std::string FLOAT_TYPENAME_SLUG = "_ARON_FLOAT";
+ const std::string DOUBLE_TYPENAME_SLUG = "_ARON_DOUBLE";
+ const std::string STRING_TYPENAME_SLUG = "_ARON_STRING";
+ const std::string BOOL_TYPENAME_SLUG = "_ARON_BOOL";
+ const std::string TIME_TYPENAME_SLUG = "_ARON_TIME";
+ }
+
+ namespace conversion
+ {
+ const std::map<type::Descriptor, std::string> Descriptor2String = {
+ {type::Descriptor::eDict, rw::json::constantes::DICT_TYPENAME_SLUG},
+ {type::Descriptor::eList, rw::json::constantes::LIST_TYPENAME_SLUG},
+ {type::Descriptor::ePair, rw::json::constantes::PAIR_TYPENAME_SLUG},
+ {type::Descriptor::eTuple, rw::json::constantes::TUPLE_TYPENAME_SLUG},
+ {type::Descriptor::eObject, rw::json::constantes::OBJECT_TYPENAME_SLUG},
+ {type::Descriptor::eNDArray, rw::json::constantes::NDARRAY_TYPENAME_SLUG},
+ {type::Descriptor::eMatrix, rw::json::constantes::MATRIX_TYPENAME_SLUG},
+ {type::Descriptor::eImage, rw::json::constantes::IMAGE_TYPENAME_SLUG},
+ {type::Descriptor::ePointCloud, rw::json::constantes::POINT_CLOUD_TYPENAME_SLUG},
+ {type::Descriptor::eQuaternion, rw::json::constantes::QUATERNION_TYPENAME_SLUG},
+ {type::Descriptor::ePose, rw::json::constantes::POSE_TYPENAME_SLUG},
+ {type::Descriptor::ePosition, rw::json::constantes::POSITION_TYPENAME_SLUG},
+ {type::Descriptor::eOrientation, rw::json::constantes::ORIENTATION_TYPENAME_SLUG},
+ {type::Descriptor::eIntEnum, rw::json::constantes::INT_ENUM_TYPENAME_SLUG},
+ {type::Descriptor::eInt, rw::json::constantes::INT_TYPENAME_SLUG},
+ {type::Descriptor::eLong, rw::json::constantes::LONG_TYPENAME_SLUG},
+ {type::Descriptor::eFloat, rw::json::constantes::FLOAT_TYPENAME_SLUG},
+ {type::Descriptor::eDouble, rw::json::constantes::DOUBLE_TYPENAME_SLUG},
+ {type::Descriptor::eBool, rw::json::constantes::BOOL_TYPENAME_SLUG},
+ {type::Descriptor::eString, rw::json::constantes::STRING_TYPENAME_SLUG},
+ {type::Descriptor::eTime, rw::json::constantes::TIME_TYPENAME_SLUG}
+ };
+ const auto String2Descriptor = aron::conversion::util::InvertMap(Descriptor2String);
+
+ const std::map<type::Maybe, std::string> Maybe2String =
+ {
+ {type::Maybe::eNone, "type::maybe::none"},
+ {type::Maybe::eOptional, "type::maybe::optional"},
+ {type::Maybe::eRawPointer, "type::maybe::raw_ptr"},
+ {type::Maybe::eSharedPointer, "type::maybe::shared_ptr"},
+ {type::Maybe::eUniquePointer, "type::maybe::unique_ptr"}
+ };
+ const auto String2Maybe = aron::conversion::util::InvertMap(Maybe2String);
+
+ const std::map<type::ndarray::ElementType, std::string> NDArrayType2String =
+ {
+ {type::ndarray::ElementType::int8, "type::ndarray::int8"},
+ {type::ndarray::ElementType::int16, "type::ndarray::int16"},
+ {type::ndarray::ElementType::int32, "type::ndarray::int32"},
+ {type::ndarray::ElementType::uint8, "type::ndarray::uint8"},
+ {type::ndarray::ElementType::uint16, "type::ndarray::uint16"},
+ {type::ndarray::ElementType::uint32, "type::ndarray::uint32"},
+ {type::ndarray::ElementType::float32, "type::ndarray::float32"},
+ {type::ndarray::ElementType::float64, "type::ndarray::float64"}
+ };
+ const auto String2NDArrayType = aron::conversion::util::InvertMap(NDArrayType2String);
+
+ const std::map<type::matrix::ElementType, std::string> MatrixType2String =
+ {
+ {type::matrix::ElementType::int16, "type::matrix::int16"},
+ {type::matrix::ElementType::int32, "type::matrix::int32"},
+ {type::matrix::ElementType::int64, "type::matrix::int64"},
+ {type::matrix::ElementType::float32, "type::matrix::float32"},
+ {type::matrix::ElementType::float64, "type::matrix::float64"}
+ };
+ const auto String2MatrixType = aron::conversion::util::InvertMap(MatrixType2String);
+
+ const std::map<type::quaternion::ElementType, std::string> QuaternionType2String =
+ {
+ {type::quaternion::ElementType::float32, "type::quaternion::float32"},
+ {type::quaternion::ElementType::float64, "type::quaternion::float64"}
+ };
+ const auto String2QuaternionType = aron::conversion::util::InvertMap(QuaternionType2String);
+
+ const std::map<type::image::PixelType, std::string> PixelType2String =
+ {
+ {type::image::PixelType::rgb24, "type::image::rgb24"},
+ {type::image::PixelType::depth32, "type::image::depth32"}
+ };
+ const auto String2PixelType = aron::conversion::util::InvertMap(PixelType2String);
+
+ const std::map<type::pointcloud::VoxelType, std::string> VoxelType2String =
+ {
+ {type::pointcloud::VoxelType::PointXYZ, "type::pointcloud::pointxyz"},
+ {type::pointcloud::VoxelType::PointXYZI, "type::pointcloud::pointxyzi"},
+ {type::pointcloud::VoxelType::PointXYZL, "type::pointcloud::pointxyzl"},
+ {type::pointcloud::VoxelType::PointXYZRGB, "type::pointcloud::pointxyzrgb"},
+ {type::pointcloud::VoxelType::PointXYZRGBA, "type::pointcloud::pointxyzrgba"},
+ {type::pointcloud::VoxelType::PointXYZRGBL, "type::pointcloud::pointxyzrgbl"},
+ {type::pointcloud::VoxelType::PointXYZHSV, "type::pointcloud::pointxyzhsv"}
+ };
+ const auto String2VoxelType = aron::conversion::util::InvertMap(VoxelType2String);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp b/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ffd1fe1e601e172bbbb0e52751a554b7d95c2c6
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.cpp
@@ -0,0 +1,212 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+#include <memory>
+#include <numeric>
+
+// Header
+#include "NlohmannJSONReader.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include "../../json/Data.h"
+
+namespace armarx::aron::type::reader
+{
+ namespace
+ {
+ /// Throw an exception if the type is other than expected
+ void checkInputForCorrectType(const nlohmann::json& input, const std::string& expectedType)
+ {
+ if (input[rw::json::constantes::TYPE_SLUG] != expectedType)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Wrong type in json encountered.", input[rw::json::constantes::TYPE_SLUG], expectedType);
+ }
+ }
+ }
+
+ void NlohmannJSONReader::readObject(const nlohmann::json& input, std::string& name, std::map<std::string, nlohmann::json>& memberTypes, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::OBJECT_TYPENAME_SLUG);
+
+ name = input[rw::json::constantes::NAME_SLUG];
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+
+ memberTypes = input[rw::json::constantes::MEMBERS_SLUG].get<std::map<std::string, nlohmann::json>>();
+ }
+ void NlohmannJSONReader::readList(const nlohmann::json& input, nlohmann::json& acceptedType, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::LIST_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ acceptedType = input[rw::json::constantes::ACCEPTED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readDict(const nlohmann::json& input, nlohmann::json& acceptedType, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::DICT_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ acceptedType = input[rw::json::constantes::ACCEPTED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readTuple(const nlohmann::json& input, std::vector<nlohmann::json>& acceptedTypes, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::TUPLE_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ acceptedTypes = input[rw::json::constantes::ACCEPTED_TYPE_SLUG].get<std::vector<nlohmann::json>>();
+ }
+
+ void NlohmannJSONReader::readPair(const nlohmann::json& input, std::pair<nlohmann::json, nlohmann::json>& acceptedTypes, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::PAIR_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ auto list = input[rw::json::constantes::ACCEPTED_TYPE_SLUG].get<std::vector<nlohmann::json>>();
+ acceptedTypes.first = list[0];
+ acceptedTypes.second = list[1];
+ }
+
+ void NlohmannJSONReader::readNDArray(const nlohmann::json& input, int& ndim, type::ndarray::ElementType& type, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::NDARRAY_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ ndim = input[rw::json::constantes::DIMENSIONS_SLUG];
+ type = input[rw::json::constantes::USED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readMatrix(const nlohmann::json& input, int& rows, int& cols, type::matrix::ElementType& type, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::MATRIX_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ auto list = input[rw::json::constantes::DIMENSIONS_SLUG].get<std::vector<nlohmann::json>>();
+ rows = list[0];
+ cols = list[1];
+ type = input[rw::json::constantes::USED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readQuaternion(const nlohmann::json& input, type::quaternion::ElementType& type, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::QUATERNION_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ type = input[rw::json::constantes::USED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readPointCloud(const nlohmann::json& input, type::pointcloud::VoxelType& type, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::POINT_CLOUD_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ type = input[rw::json::constantes::USED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readImage(const nlohmann::json& input, type::image::PixelType& type, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::IMAGE_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ type = input[rw::json::constantes::USED_TYPE_SLUG];
+ }
+
+ void NlohmannJSONReader::readPosition(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::POSITION_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readOrientation(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::ORIENTATION_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readPose(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::POSE_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readIntEnum(const nlohmann::json& input, std::string& name, std::map<std::string, int>& acceptedValues, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::INT_ENUM_TYPENAME_SLUG);
+
+ name = input[rw::json::constantes::NAME_SLUG];
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+
+ acceptedValues = input[rw::json::constantes::ELEMENTS_SLUG].get<std::map<std::string, int>>();
+ }
+
+ void NlohmannJSONReader::readInt(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::INT_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readLong(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::LONG_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readFloat(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::FLOAT_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readDouble(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::DOUBLE_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readString(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::STRING_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readBool(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::BOOL_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+
+ void NlohmannJSONReader::readTime(const nlohmann::json& input, type::Maybe& maybe)
+ {
+ checkInputForCorrectType(input, rw::json::constantes::TIME_TYPENAME_SLUG);
+
+ maybe = rw::json::conversion::String2Maybe.at(input[rw::json::constantes::MAYBE_SLUG]);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.h b/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..45b0a79501c3b9891081f1ba02dbe10c287014e5
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/reader/nlohmannJSON/NlohmannJSONReader.h
@@ -0,0 +1,67 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <stack>
+
+// Simox
+#include <SimoxUtility/json.h>
+
+// BaseClass
+#include <RobotAPI/libraries/aron/core/type/rw/Reader.h>
+
+namespace armarx::aron::type::reader
+{
+ class NlohmannJSONReader :
+ public ReaderInterface<nlohmann::json>
+ {
+ public:
+ // constructors
+ NlohmannJSONReader() = default;
+
+ void readObject(const nlohmann::json& input, std::string& name, std::map<std::string, nlohmann::json>& memberTypes, type::Maybe& maybe) override;
+ void readList(const nlohmann::json& input, nlohmann::json& acceptedType, type::Maybe& maybe) override;
+ void readDict(const nlohmann::json& input, nlohmann::json& acceptedType, type::Maybe& maybe) override;
+ void readTuple(const nlohmann::json& input, std::vector<nlohmann::json>& acceptedTypes, type::Maybe& maybe) override;
+ void readPair(const nlohmann::json& input, std::pair<nlohmann::json, nlohmann::json>& acceptedTypes, type::Maybe& maybe) override;
+
+ void readNDArray(const nlohmann::json& input, int& ndim, type::ndarray::ElementType& type, type::Maybe& maybe) override;
+ void readMatrix(const nlohmann::json& input, int& rows, int& cols, type::matrix::ElementType& type, type::Maybe& maybe) override;
+ void readQuaternion(const nlohmann::json& input, type::quaternion::ElementType& type, type::Maybe& maybe) override;
+ void readPointCloud(const nlohmann::json& input, type::pointcloud::VoxelType& type, type::Maybe& maybe) override;
+ void readImage(const nlohmann::json& input, type::image::PixelType& type, type::Maybe& maybe) override;
+ void readPosition(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readOrientation(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readPose(const nlohmann::json& input, type::Maybe& maybe) override;
+
+ void readIntEnum(const nlohmann::json& input, std::string& name, std::map<std::string, int>& acceptedValues, type::Maybe& maybe) override;
+
+ void readInt(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readLong(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readFloat(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readDouble(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readString(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readBool(const nlohmann::json& input, type::Maybe& maybe) override;
+ void readTime(const nlohmann::json& input, type::Maybe& maybe) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.cpp b/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1be314139760812547a91a5a76c78d6c5f404053
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.cpp
@@ -0,0 +1,196 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+// STD/STL
+#include <memory>
+#include <numeric>
+
+// Header
+#include "VariantReader.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+
+namespace armarx::aron::type::reader
+{
+ void NavigatorReader::readObject(const aron::type::VariantPtr& input, std::string& name, std::map<std::string, aron::type::VariantPtr>& memberTypes, type::Maybe& maybe)
+ {
+ auto o = type::Object::DynamicCastAndCheck(input);
+
+ name = o->getObjectName();
+ maybe = o->getMaybe();
+ memberTypes = o->getMemberTypes();
+ }
+ void NavigatorReader::readList(const aron::type::VariantPtr& input, aron::type::VariantPtr& acceptedType, type::Maybe& maybe)
+ {
+ auto o = type::List::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ acceptedType = o->getAcceptedType();
+ }
+
+ void NavigatorReader::readDict(const aron::type::VariantPtr& input, aron::type::VariantPtr& acceptedType, type::Maybe& maybe)
+ {
+ auto o = type::Dict::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ acceptedType = o->getAcceptedType();
+ }
+
+ void NavigatorReader::readTuple(const aron::type::VariantPtr& input, std::vector<aron::type::VariantPtr>& acceptedTypes, type::Maybe& maybe)
+ {
+ auto o = type::Tuple::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ acceptedTypes = o->getAcceptedTypes();
+ }
+
+ void NavigatorReader::readPair(const aron::type::VariantPtr& input, std::pair<aron::type::VariantPtr, aron::type::VariantPtr>& acceptedTypes, type::Maybe& maybe)
+ {
+ auto o = type::Pair::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ acceptedTypes = o->getAcceptedTypes();
+ }
+
+ void NavigatorReader::readNDArray(const aron::type::VariantPtr& input, int& ndim, type::ndarray::ElementType& type, type::Maybe& maybe)
+ {
+ auto o = type::NDArray::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ ndim = o->getNumberDimensions();
+ type = o->getElementType();
+ }
+
+ void NavigatorReader::readMatrix(const aron::type::VariantPtr& input, int& rows, int& cols, type::matrix::ElementType& type, type::Maybe& maybe)
+ {
+ auto o = type::Matrix::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ rows = o->getRows();
+ cols = o->getCols();
+ type = o->getElementType();
+ }
+
+ void NavigatorReader::readQuaternion(const aron::type::VariantPtr& input, type::quaternion::ElementType& type, type::Maybe& maybe)
+ {
+ auto o = type::Quaternion::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ type = o->getElementType();
+ }
+
+ void NavigatorReader::readPointCloud(const aron::type::VariantPtr& input, type::pointcloud::VoxelType& type, type::Maybe& maybe)
+ {
+ auto o = type::PointCloud::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ type = o->getVoxelType();
+ }
+
+ void NavigatorReader::readImage(const aron::type::VariantPtr& input, type::image::PixelType& type, type::Maybe& maybe)
+ {
+ auto o = type::Image::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ type = o->getPixelType();
+ }
+
+ void NavigatorReader::readPosition(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Position::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readOrientation(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Orientation::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readPose(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Pose::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readIntEnum(const aron::type::VariantPtr& input, std::string& name, std::map<std::string, int>& acceptedValues, type::Maybe& maybe)
+ {
+ auto o = type::IntEnum::DynamicCastAndCheck(input);
+
+ name = o->getEnumName();
+ acceptedValues = o->getAcceptedValueMap();
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readInt(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Int::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readLong(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Long::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readFloat(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Float::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readDouble(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Double::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readString(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::String::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readBool(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Bool::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+
+ void NavigatorReader::readTime(const aron::type::VariantPtr& input, type::Maybe& maybe)
+ {
+ auto o = type::Time::DynamicCastAndCheck(input);
+
+ maybe = o->getMaybe();
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.h b/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a453e6a1683585277b52d075539edce5c377ff8
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/reader/variant/VariantReader.h
@@ -0,0 +1,68 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <stack>
+
+// BaseClass
+#include <RobotAPI/libraries/aron/core/type/rw/Reader.h>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+
+
+namespace armarx::aron::type::reader
+{
+ class NavigatorReader :
+ public ReaderInterface<aron::type::VariantPtr>
+ {
+ public:
+ // constructors
+ NavigatorReader() = default;
+
+ void readObject(const aron::type::VariantPtr& input, std::string& name, std::map<std::string, aron::type::VariantPtr>& memberTypes, type::Maybe& maybe) override;
+ void readList(const aron::type::VariantPtr& input, aron::type::VariantPtr& acceptedType, type::Maybe& maybe) override;
+ void readDict(const aron::type::VariantPtr& input, aron::type::VariantPtr& acceptedType, type::Maybe& maybe) override;
+ void readTuple(const aron::type::VariantPtr& input, std::vector<aron::type::VariantPtr>& acceptedTypes, type::Maybe& maybe) override;
+ void readPair(const aron::type::VariantPtr& input, std::pair<aron::type::VariantPtr, aron::type::VariantPtr>& acceptedTypes, type::Maybe& maybe) override;
+
+ void readNDArray(const aron::type::VariantPtr& input, int& ndim, type::ndarray::ElementType& type, type::Maybe& maybe) override;
+ void readMatrix(const aron::type::VariantPtr& input, int& rows, int& cols, type::matrix::ElementType& type, type::Maybe& maybe) override;
+ void readQuaternion(const aron::type::VariantPtr& input, type::quaternion::ElementType& type, type::Maybe& maybe) override;
+ void readPointCloud(const aron::type::VariantPtr& input, type::pointcloud::VoxelType& type, type::Maybe& maybe) override;
+ void readImage(const aron::type::VariantPtr& input, type::image::PixelType& type, type::Maybe& maybe) override;
+ void readPosition(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readOrientation(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readPose(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+
+ void readIntEnum(const aron::type::VariantPtr& input, std::string& name, std::map<std::string, int>& acceptedValues, type::Maybe& maybe) override;
+
+ void readInt(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readLong(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readFloat(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readDouble(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readString(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readBool(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ void readTime(const aron::type::VariantPtr& input, type::Maybe& maybe) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp b/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ce67f26c47d70e6e45f447ca36ad7d97b240aa8
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.cpp
@@ -0,0 +1,217 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller (fabian dot peller at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "NlohmannJSONWriter.h"
+
+// Constantes
+#include "../../json/Data.h"
+
+namespace armarx::aron::type::writer
+{
+ namespace
+ {
+ /// Set important members for json object (aron meta information)
+ void setupAronInformationForType(nlohmann::json& json, const std::string& type, const type::Maybe& maybe)
+ {
+ json[rw::json::constantes::TYPE_SLUG] = type;
+ json[rw::json::constantes::MAYBE_SLUG] = rw::json::conversion::Maybe2String.at(maybe);
+ }
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeObject(const std::string& name, const type::Maybe maybe, const std::map<std::string, nlohmann::json>& memberTypes, const std::optional<nlohmann::json>& extends)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::OBJECT_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::NAME_SLUG] = name;
+ if (extends.has_value())
+ {
+ o[rw::json::constantes::EXTENDS_SLUG] = *extends;
+ }
+
+ o[rw::json::constantes::MEMBERS_SLUG] = nlohmann::json(nlohmann::json::value_t::object);
+ for (const auto& [key, value] : memberTypes)
+ {
+ o[rw::json::constantes::MEMBERS_SLUG][key] = value;
+ }
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeList(const type::Maybe maybe, const nlohmann::json& acceptedType)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::LIST_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::ACCEPTED_TYPE_SLUG] = acceptedType;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeDict(const type::Maybe maybe, const nlohmann::json& acceptedType)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::DICT_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::ACCEPTED_TYPE_SLUG] = acceptedType;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writePair(const type::Maybe maybe, const nlohmann::json& acceptedType1, const nlohmann::json& acceptedType2)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::PAIR_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::ACCEPTED_TYPE_SLUG] = {acceptedType1, acceptedType2};
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeTuple(const type::Maybe maybe, const std::vector<nlohmann::json>& acceptedTypes)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::TUPLE_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::ACCEPTED_TYPE_SLUG] = acceptedTypes;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeNDArray(const int ndim, const type::ndarray::ElementType type, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::NDARRAY_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::USED_TYPE_SLUG] = rw::json::conversion::NDArrayType2String.at(type);
+ o[rw::json::constantes::DIMENSIONS_SLUG] = ndim;
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeMatrix(const int rows, const int cols, const type::matrix::ElementType type, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::MATRIX_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::USED_TYPE_SLUG] = rw::json::conversion::MatrixType2String.at(type);
+ o[rw::json::constantes::DIMENSIONS_SLUG] = {rows, cols};
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeQuaternion(const type::quaternion::ElementType type, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::QUATERNION_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::USED_TYPE_SLUG] = rw::json::conversion::QuaternionType2String.at(type);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeImage(const type::image::PixelType type, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::IMAGE_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::USED_TYPE_SLUG] = rw::json::conversion::PixelType2String.at(type);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writePointCloud(const type::pointcloud::VoxelType type, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::POINT_CLOUD_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::USED_TYPE_SLUG] = rw::json::conversion::VoxelType2String.at(type);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writePosition(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::POSITION_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeOrientation(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::ORIENTATION_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writePose(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::POSE_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeIntEnum(const std::string& name, const std::map<std::string, int>& acceptedValues, const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::INT_ENUM_TYPENAME_SLUG, maybe);
+ o[rw::json::constantes::NAME_SLUG] = name;
+
+ o[rw::json::constantes::ELEMENTS_SLUG] = nlohmann::json(nlohmann::json::value_t::object);
+ for (const auto& [key, value] : acceptedValues)
+ {
+ o[rw::json::constantes::ELEMENTS_SLUG][key] = value;
+ }
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeInt(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::INT_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeLong(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::LONG_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeFloat(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::FLOAT_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeDouble(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::DOUBLE_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeString(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::STRING_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeBool(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::BOOL_TYPENAME_SLUG, maybe);
+ return o;
+ }
+
+ nlohmann::json NlohmannJSONWriter::writeTime(const type::Maybe maybe)
+ {
+ nlohmann::json o;
+ setupAronInformationForType(o, rw::json::constantes::TIME_TYPENAME_SLUG, maybe);
+ return o;
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.h b/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c52035d64fd857d09257a3fc9eee4d2c85860e01
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/writer/nlohmannJSON/NlohmannJSONWriter.h
@@ -0,0 +1,67 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD / STL
+#include <memory>
+#include <stack>
+#include <sstream>
+
+// Simox
+#include <SimoxUtility/json.h>
+
+// Base Class
+#include <RobotAPI/libraries/aron/core/type/rw/Writer.h>
+
+namespace armarx::aron::type::writer
+{
+ class NlohmannJSONWriter :
+ public WriterInterface<nlohmann::json>
+ {
+ public:
+ NlohmannJSONWriter() = default;
+
+ virtual nlohmann::json writeObject(const std::string& name, const type::Maybe maybe, const std::map<std::string, nlohmann::json>& memberTypes, const std::optional<nlohmann::json>& extends = std::nullopt) override;
+ virtual nlohmann::json writeList(const type::Maybe maybe, const nlohmann::json& acceptedType) override;
+ virtual nlohmann::json writeDict(const type::Maybe maybe, const nlohmann::json& acceptedType) override;
+ virtual nlohmann::json writePair(const type::Maybe maybe, const nlohmann::json& acceptedType1, const nlohmann::json& acceptedType2) override;
+ virtual nlohmann::json writeTuple(const type::Maybe maybe, const std::vector<nlohmann::json>& acceptedTypes) override;
+
+ virtual nlohmann::json writeNDArray(const int ndim, const type::ndarray::ElementType, const type::Maybe maybe) override;
+ virtual nlohmann::json writeMatrix(const int rows, const int cols, const type::matrix::ElementType type, const type::Maybe maybe) override;
+ virtual nlohmann::json writeQuaternion(const type::quaternion::ElementType, const type::Maybe maybe) override;
+ virtual nlohmann::json writeImage(const type::image::PixelType, const type::Maybe maybe) override;
+ virtual nlohmann::json writePointCloud(const type::pointcloud::VoxelType, const type::Maybe maybe) override;
+ virtual nlohmann::json writePosition(const type::Maybe maybe) override;
+ virtual nlohmann::json writeOrientation(const type::Maybe maybe) override;
+ virtual nlohmann::json writePose(const type::Maybe maybe) override;
+
+ virtual nlohmann::json writeIntEnum(const std::string& name, const std::map<std::string, int>& acceptedValues, const type::Maybe maybe) override;
+
+ virtual nlohmann::json writeInt(const type::Maybe maybe) override;
+ virtual nlohmann::json writeLong(const type::Maybe maybe) override;
+ virtual nlohmann::json writeFloat(const type::Maybe maybe) override;
+ virtual nlohmann::json writeDouble(const type::Maybe maybe) override;
+ virtual nlohmann::json writeString(const type::Maybe maybe) override;
+ virtual nlohmann::json writeBool(const type::Maybe maybe) override;
+ virtual nlohmann::json writeTime(const type::Maybe maybe) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.cpp b/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40d0871bf24f0889d8f5e0687633a2b2dca0a722
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.cpp
@@ -0,0 +1,188 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#include "VariantWriter.h"
+
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+#include <memory>
+#include <numeric>
+
+
+namespace armarx::aron::type::writer
+{
+ // interface
+ aron::type::VariantPtr VariantWriter::writeObject(const std::string& name, const type::Maybe maybe, const std::map<std::string, aron::type::VariantPtr>& memberTypes, const std::optional<aron::type::VariantPtr>& extends)
+ {
+ auto o = std::make_shared<type::Object>(name, memberTypes);
+ o->setMaybe(maybe);
+ if (extends.has_value())
+ {
+ auto ex = type::Object::DynamicCast(*extends);
+ o->setExtends(ex);
+ }
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeList(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType)
+ {
+ auto o = std::make_shared<type::List>(acceptedType);
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeDict(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType)
+ {
+ auto o = std::make_shared<type::Dict>(acceptedType);
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writePair(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType1, const aron::type::VariantPtr& acceptedType2)
+ {
+ auto o = std::make_shared<type::Pair>(acceptedType1, acceptedType2);
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeTuple(const type::Maybe maybe, const std::vector<aron::type::VariantPtr>& acceptedTypes)
+ {
+ auto o = std::make_shared<type::Tuple>(acceptedTypes);
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeNDArray(const int ndim, const type::ndarray::ElementType, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::NDArray>();
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeMatrix(const int rows, const int cols, const type::matrix::ElementType type, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Matrix>();
+ o->setMaybe(maybe);
+ o->setRows(rows);
+ o->setCols(cols);
+ o->setElementType(type);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeQuaternion(const type::quaternion::ElementType type, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Quaternion>();
+ o->setMaybe(maybe);
+ o->setElementType(type);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeImage(const type::image::PixelType type, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Image>();
+ o->setMaybe(maybe);
+ o->setPixelType(type);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writePointCloud(const type::pointcloud::VoxelType type, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::PointCloud>();
+ o->setMaybe(maybe);
+ o->setVoxelType(type);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writePosition(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Position>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeOrientation(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Orientation>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writePose(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Pose>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeIntEnum(const std::string& name, const std::map<std::string, int>& acceptedValues, const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::IntEnum>(name, acceptedValues);
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeInt(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Int>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeLong(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Long>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeFloat(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Float>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeDouble(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Double>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeString(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::String>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeBool(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Bool>();
+ o->setMaybe(maybe);
+ return o;
+ }
+
+ aron::type::VariantPtr VariantWriter::writeTime(const type::Maybe maybe)
+ {
+ auto o = std::make_shared<type::Time>();
+ o->setMaybe(maybe);
+ return o;
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h b/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2f1056296ea0733597c36c889f8a4776b3d2b7c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h
@@ -0,0 +1,63 @@
+/*
+* This file is part of ArmarX.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller (fabian dot peller at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+#include <RobotAPI/libraries/aron/core/type/rw/Writer.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+
+#include <memory>
+#include <stack>
+
+
+namespace armarx::aron::type::writer
+{
+ class VariantWriter :
+ public type::WriterInterface<aron::type::VariantPtr>
+ {
+ public:
+ VariantWriter() = default;
+
+ virtual aron::type::VariantPtr writeObject(const std::string& name, const type::Maybe maybe, const std::map<std::string, aron::type::VariantPtr>& memberTypes, const std::optional<aron::type::VariantPtr>& extends = std::nullopt) override;
+ virtual aron::type::VariantPtr writeList(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType) override;
+ virtual aron::type::VariantPtr writeDict(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType) override;
+ virtual aron::type::VariantPtr writePair(const type::Maybe maybe, const aron::type::VariantPtr& acceptedType1, const aron::type::VariantPtr& acceptedType2) override;
+ virtual aron::type::VariantPtr writeTuple(const type::Maybe maybe, const std::vector<aron::type::VariantPtr>& acceptedTypes) override;
+
+ virtual aron::type::VariantPtr writeNDArray(const int ndim, const type::ndarray::ElementType, const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeMatrix(const int rows, const int cols, const type::matrix::ElementType type, const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeQuaternion(const type::quaternion::ElementType, const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeImage(const type::image::PixelType, const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writePointCloud(const type::pointcloud::VoxelType, const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writePosition(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeOrientation(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writePose(const type::Maybe maybe) override;
+
+ virtual aron::type::VariantPtr writeIntEnum(const std::string& name, const std::map<std::string, int>& acceptedValues, const type::Maybe maybe) override;
+
+ virtual aron::type::VariantPtr writeInt(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeLong(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeFloat(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeDouble(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeString(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeBool(const type::Maybe maybe) override;
+ virtual aron::type::VariantPtr writeTime(const type::Maybe maybe) override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/All.h b/source/RobotAPI/libraries/aron/core/type/variant/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4a66915a85ad4bf34128f13288ea32fd651e4c3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/All.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "container/All.h"
+#include "ndarray/All.h"
+#include "enum/All.h"
+#include "primitive/All.h"
+
+/**
+ * A convenience header to include all aron files (full include, not forward declared)
+ */
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/Factory.cpp b/source/RobotAPI/libraries/aron/core/type/variant/Factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16fb41506f61ff66a1d7d3770c869858e7f9370d
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/Factory.cpp
@@ -0,0 +1,65 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// STD/STL
+
+// Header
+#include "Factory.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+
+namespace armarx::aron::type
+{
+ // Access method
+ std::unique_ptr<type::Variant> VariantFactory::create(const type::dto::GenericType& aron, const Path& path) const
+ {
+ auto descriptor = type::Aron2Descriptor(aron);
+ switch(descriptor)
+ {
+ case type::Descriptor::eList: return std::make_unique<type::List>(dynamic_cast<const type::dto::List&>(aron), path);
+ case type::Descriptor::eDict: return std::make_unique<type::Dict>(dynamic_cast<const type::dto::Dict&>(aron), path);
+ case type::Descriptor::ePair: return std::make_unique<type::Pair>(dynamic_cast<const type::dto::Pair&>(aron), path);
+ case type::Descriptor::eTuple: return std::make_unique<type::Tuple>(dynamic_cast<const type::dto::Tuple&>(aron), path);
+ case type::Descriptor::eObject: return std::make_unique<type::Object>(dynamic_cast<const type::dto::AronObject&>(aron), path);
+ case type::Descriptor::eNDArray: return std::make_unique<type::NDArray>(dynamic_cast<const type::dto::NDArray&>(aron), path);
+ case type::Descriptor::eMatrix: return std::make_unique<type::Matrix>(dynamic_cast<const type::dto::Matrix&>(aron), path);
+ case type::Descriptor::eImage: return std::make_unique<type::Image>(dynamic_cast<const type::dto::Image&>(aron), path);
+ case type::Descriptor::eOrientation: return std::make_unique<type::Orientation>(dynamic_cast<const type::dto::Orientation&>(aron), path);
+ case type::Descriptor::ePointCloud: return std::make_unique<type::PointCloud>(dynamic_cast<const type::dto::PointCloud&>(aron), path);
+ case type::Descriptor::ePose: return std::make_unique<type::Pose>(dynamic_cast<const type::dto::Pose&>(aron), path);
+ case type::Descriptor::ePosition: return std::make_unique<type::Position>(dynamic_cast<const type::dto::Position&>(aron), path);
+ case type::Descriptor::eQuaternion: return std::make_unique<type::Quaternion>(dynamic_cast<const type::dto::Quaternion&>(aron), path);
+ case type::Descriptor::eIntEnum: return std::make_unique<type::IntEnum>(dynamic_cast<const type::dto::IntEnum&>(aron), path);
+ case type::Descriptor::eInt: return std::make_unique<type::Int>(dynamic_cast<const type::dto::AronInt&>(aron), path);
+ case type::Descriptor::eLong: return std::make_unique<type::Long>(dynamic_cast<const type::dto::AronLong&>(aron), path);
+ case type::Descriptor::eFloat: return std::make_unique<type::Float>(dynamic_cast<const type::dto::AronFloat&>(aron), path);
+ case type::Descriptor::eDouble: return std::make_unique<type::Double>(dynamic_cast<const type::dto::AronDouble&>(aron), path);
+ case type::Descriptor::eString: return std::make_unique<type::String>(dynamic_cast<const type::dto::AronString&>(aron), path);
+ case type::Descriptor::eBool: return std::make_unique<type::Bool>(dynamic_cast<const type::dto::AronBool&>(aron), path);
+ case type::Descriptor::eTime: return std::make_unique<type::Time>(dynamic_cast<const type::dto::AronTime&>(aron), path);
+ default: throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Got an unknown descriptor", std::to_string((int) descriptor) + " aka " + defaultconversion::string::Descriptor2String.at(descriptor), path);
+ }
+ }
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/NavigatorFactory.h b/source/RobotAPI/libraries/aron/core/type/variant/Factory.h
similarity index 63%
rename from source/RobotAPI/libraries/aron/core/navigator/NavigatorFactory.h
rename to source/RobotAPI/libraries/aron/core/type/variant/Factory.h
index f66f163ee906f4e1c20b4a48e0882b1a3f2a6bc0..520004578707bf18aea32a34b37ed4b0b5ef8775 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/NavigatorFactory.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/Factory.h
@@ -25,27 +25,25 @@
// STD/STL
#include <memory>
-#include <string>
#include <unordered_map>
-// Base Class
-#include <RobotAPI/libraries/aron/core/Factory.h>
-
// ArmarX
-#include <RobotAPI/interface/aron.h>
-#include <RobotAPI/libraries/aron/core/Concepts.h>
-#include <RobotAPI/libraries/aron/core/Path.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
-namespace armarx::aron
+namespace armarx::aron::type
{
- template <typename Input, typename Output, typename EnumT> // requires ...
- class NavigatorFactory :
- virtual public Factory<Input, Output>
+ /**
+ * @brief The VariantFactory class. It converts an aron::type::dto obeject into a variant object.
+ */
+ class VariantFactory
{
public:
- NavigatorFactory() = default;
+ VariantFactory() = default;
+
+ /// the create methods. Basically does a switch case over the ice_id of the dto and then returns a new variant object
+ std::unique_ptr<type::Variant> create(const type::dto::GenericType&, const Path&) const;
- virtual Output create(const Input&, const Path&) const = 0;
- virtual Output createSpecific(const Input&, const Path&) const = 0;
+ virtual ~VariantFactory() = default;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/Navigator.cpp b/source/RobotAPI/libraries/aron/core/type/variant/Variant.cpp
similarity index 74%
rename from source/RobotAPI/libraries/aron/core/navigator/type/Navigator.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/Variant.cpp
index 2e3eb1e69cb967cb833ef78bee55d6e2fbaf527b..f496b4f3fa380cc60b563b4c7beae47e754a8d15 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/Navigator.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/Variant.cpp
@@ -24,19 +24,19 @@
// STD/STL
// Header
-#include "Navigator.h"
+#include "Variant.h"
// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Factory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* Navigator */
// static data members
- const NavigatorFactoryPtr Navigator::FACTORY = NavigatorFactoryPtr(new NavigatorFactory());
+ const VariantFactoryPtr Variant::FACTORY = VariantFactoryPtr(new VariantFactory());
- NavigatorPtr Navigator::FromAronType(const type::AronTypePtr& a, const Path& path)
+ VariantPtr Variant::FromAronDTO(const type::dto::GenericType& a, const Path& path)
{
return FACTORY->create(a, path);
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/Variant.h b/source/RobotAPI/libraries/aron/core/type/variant/Variant.h
new file mode 100644
index 0000000000000000000000000000000000000000..c287a8bf4c54f50d01f49b8a6ebe295df4372271
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/Variant.h
@@ -0,0 +1,132 @@
+/*
+* This file is part of ArmarX.
+*
+* Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+* Karlsruhe Institute of Technology (KIT), all rights reserved.
+*
+* ArmarX is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* ArmarX is distributed in the hope that it will be useful, but
+* WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
+* @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+* GNU General Public License
+*/
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <vector>
+#include <map>
+#include <string>
+
+// Simox
+// #include <SimoxUtility/algorithm/string.h>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/Exception.h>
+#include <RobotAPI/interface/aron.h>
+#include <RobotAPI/libraries/aron/core/Descriptor.h>
+
+namespace armarx::aron::type
+{
+ class VariantFactory;
+ typedef std::unique_ptr<VariantFactory> VariantFactoryPtr;
+
+ class Variant;
+ typedef std::shared_ptr<Variant> VariantPtr;
+
+ /**
+ * @brief The Variant class. This is the parent class of all type variant objects. It provides basic methods to get the children of a type, to get the descriptor, etc.
+ * Usually, you get a VariantPtr as input to your code. You can use the descriptor to find out, which specific type is behind a variant. It is type safe.
+ * For casting, every variant implementation provides the DynamicCast method, which casts a pointer to the static used type.
+ *
+ * This implementation wraps around the underlying ice object (armarx::aron::type::dto::XXX). All data is stored in the ice handle.
+ * However, for simplicity, container types also contain pointers to their children variants
+ *
+ * Each ice type object has a special member 'maybeType' which holds an enum containing the information of if this type is a pointer, an optional or something else.
+ */
+ class Variant
+ {
+ public:
+ using PointerType = VariantPtr;
+
+ public:
+ // constructors
+ Variant(const type::Descriptor& descriptor, const Path& path = Path()) :
+ descriptor(descriptor),
+ path(path)
+ {
+ }
+ virtual ~Variant() = default;
+
+ // operators
+ virtual bool operator==(const Variant& other) const = 0;
+ bool operator==(const VariantPtr& other) const
+ {
+ if (!other)
+ {
+ return false;
+ }
+
+ return *this == *other;
+ }
+
+ // static methods
+ /// create a variant object from an dto object
+ static VariantPtr FromAronDTO(const type::dto::GenericType&, const Path& = Path());
+
+ // public methods
+ type::Descriptor getDescriptor() const
+ {
+ return descriptor;
+ }
+
+ Path getPath() const
+ {
+ return path;
+ }
+
+ std::string pathToString() const
+ {
+ return path.toString();
+ }
+
+ // virtual methods
+ /// get a short name of this specific type
+ virtual std::string getShortName() const = 0;
+
+ /// get the full name of this specific type
+ virtual std::string getFullName() const = 0;
+
+ /// get all child elements
+ virtual std::vector<VariantPtr> getChildren() const = 0;
+ virtual size_t childrenSize() const = 0;
+
+ /// set the maybetype of this type
+ virtual void setMaybe(const type::Maybe m) = 0;
+
+ /// get the maybe type
+ virtual type::Maybe getMaybe() const = 0;
+
+ /// convert this variant to a dto object.
+ /// In most cases you have to use the specific conversion methods of each type implementation (e.g. to toIntDTO() to get an aron::type::dto::Int object)
+ virtual type::dto::GenericTypePtr toAronDTO() const = 0;
+
+ protected:
+ const type::Descriptor descriptor;
+ const Path path;
+
+ private:
+ static const VariantFactoryPtr FACTORY;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/All.h b/source/RobotAPI/libraries/aron/core/type/variant/container/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..80453178ce382269a1fb50273d198eff8e6bf4f3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/All.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Dict.h"
+#include "List.h"
+#include "Object.h"
+#include "Pair.h"
+#include "Tuple.h"
+
+/**
+ * A convenience header to include all container aron files (full include, not forward declared)
+ */
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
index 0b2b15fe570bbf32238da76bc1608234856e6249..d8b627b8863ed5a8c018653aef3bec957a063977 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
@@ -25,62 +25,59 @@
#include "Dict.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- DictNavigator::DictNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eDict, path)
- {
-
- }
-
- DictNavigator::DictNavigator(const type::AronDictPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eDict, path),
- detail::NavigatorBase<type::AronDict, DictNavigator>(o),
- acceptedType(FromAronType(o->acceptedType))
+ Dict::Dict(const VariantPtr& acceptedType, const Path& path) :
+ detail::ContainerVariant<type::dto::Dict, Dict>(type::Descriptor::eDict, path),
+ acceptedType(acceptedType)
{
+ aron->acceptedType = acceptedType->toAronDTO();
}
- // operators
- bool DictNavigator::operator==(const DictNavigator& other) const
+ Dict::Dict(const type::dto::Dict& o, const Path& path) :
+ detail::ContainerVariant<type::dto::Dict, Dict>(o, type::Descriptor::eDict, path),
+ acceptedType(FromAronDTO(*o.acceptedType))
{
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getAcceptedType() == other.getAcceptedType();
}
- NavigatorPtr DictNavigator::getAcceptedType() const
+ VariantPtr Dict::getAcceptedType() const
{
+ ARMARX_CHECK_NOT_NULL(acceptedType);
return acceptedType;
}
- void DictNavigator::setAcceptedType(const NavigatorPtr& a)
+ void Dict::setAcceptedType(const VariantPtr& a)
{
- this->aron->acceptedType = a->toAronTypePtr();
+ ARMARX_CHECK_NOT_NULL(a);
+ aron->acceptedType = a->toAronDTO();
acceptedType = a;
}
- type::AronDictPtr DictNavigator::toAronDictPtr() const
+ type::dto::DictPtr Dict::toDictDTO() const
{
- return this->aron;
+ return aron;
}
// virtual implementations
- std::vector<NavigatorPtr> DictNavigator::getChildren() const
+ std::vector<VariantPtr> Dict::getChildren() const
{
return {acceptedType};
}
- size_t DictNavigator::childrenSize() const
+ size_t Dict::childrenSize() const
{
return 1;
}
- std::string DictNavigator::getName() const
+ std::string Dict::getShortName() const
+ {
+ return "Dict<" + acceptedType->getShortName() + ">";
+ }
+
+ std::string Dict::getFullName() const
{
- return "AronDictType<" + acceptedType->getName() + ">";
+ return "armarx::aron::type::Dict<" + acceptedType->getFullName() + ">";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
similarity index 57%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
index 7d021d8fedb1b1185d0288728bd61c91f025b502..d458ad4bf6d3a11983dcf88b8f928a603362786d 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
@@ -28,37 +28,37 @@
#include <map>
// Base Class
-#include "../detail/ContainerNavigatorBase.h"
+#include "../detail/ContainerVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class DictNavigator;
- typedef std::shared_ptr<DictNavigator> DictNavigatorPtr;
-
- class DictNavigator :
- virtual public detail::ContainerNavigatorBase<type::AronDict, DictNavigator>
+ /**
+ * @brief The Dict class. It represents the dict type
+ * A dict only has an accepted type (a variant)
+ * for the corresponding data object @see data/variant/container/Dict.h
+ */
+ class Dict :
+ public detail::ContainerVariant<type::dto::Dict, Dict>
{
public:
// constructors
- DictNavigator(const Path& path = Path());
- DictNavigator(const type::AronDictPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const DictNavigator&) const override;
+ Dict(const VariantPtr& acceptedType, const Path& path = Path());
+ Dict(const type::dto::Dict&, const Path& path = Path());
// public member functions
- NavigatorPtr getAcceptedType() const;
- void setAcceptedType(const NavigatorPtr&);
+ VariantPtr getAcceptedType() const;
+ void setAcceptedType(const VariantPtr&);
- type::AronDictPtr toAronDictPtr() const;
+ type::dto::DictPtr toDictDTO() const;
// virtual implementations
- std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ std::vector<VariantPtr> getChildren() const override;
+ size_t childrenSize() const override;
private:
// members
- NavigatorPtr acceptedType;
+ VariantPtr acceptedType;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/List.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
index 3a20cc76d750fd3811c1e9c9a46ac874ee61dad5..47c129681572c9b1153b7ee4d30a9ab7da48a321 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
@@ -24,63 +24,59 @@
// Header
#include "List.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- ListNavigator::ListNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eList, path)
+ List::List(const VariantPtr& acceptedType, const Path& path) :
+ detail::ContainerVariant<type::dto::List, List>(type::Descriptor::eList, path),
+ acceptedType(acceptedType)
{
+ aron->acceptedType = acceptedType->toAronDTO();
}
- ListNavigator::ListNavigator(const type::AronListPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eList, path),
- detail::NavigatorBase<type::AronList, ListNavigator>(o),
- acceptedType(FromAronType(o->acceptedType))
+ List::List(const type::dto::List& o, const Path& path) :
+ detail::ContainerVariant<type::dto::List, List>(o, type::Descriptor::eList, path),
+ acceptedType(FromAronDTO(*o.acceptedType))
{
}
- // operators
- bool ListNavigator::operator==(const ListNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getAcceptedType() == other.getAcceptedType();
- }
-
// Member functions
- NavigatorPtr ListNavigator::getAcceptedType() const
+ VariantPtr List::getAcceptedType() const
{
return acceptedType;
}
- void ListNavigator::setAcceptedType(const NavigatorPtr& a)
+ void List::setAcceptedType(const VariantPtr& a)
{
ARMARX_CHECK_NOT_NULL(a);
- this->aron->acceptedType = a->toAronTypePtr();
+ aron->acceptedType = a->toAronDTO();
acceptedType = a;
}
// static methods
- type::AronListPtr ListNavigator::toAronListPtr() const
+ type::dto::ListPtr List::toListDTO() const
{
- return this->aron;
+ return aron;
}
// virtual implementations
- std::vector<NavigatorPtr> ListNavigator::getChildren() const
+ std::vector<VariantPtr> List::getChildren() const
{
return {acceptedType};
}
- size_t ListNavigator::childrenSize() const
+ size_t List::childrenSize() const
{
return 1;
}
- std::string ListNavigator::getName() const
+ std::string List::getShortName() const
+ {
+ return "List<" + acceptedType->getShortName() + ">";
+ }
+
+ std::string List::getFullName() const
{
- return "AronListType<" + acceptedType->getName() + ">";
+ return "armarx::aron::type::List<" + acceptedType->getFullName() + ">";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
similarity index 57%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/List.h
rename to source/RobotAPI/libraries/aron/core/type/variant/container/List.h
index d02ea8a6e4a0c7afb9cd7996651e66c48a22cad8..277591cf7974685b7db2908641ca0ed4c3cf13c5 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
@@ -28,37 +28,36 @@
#include <vector>
// Base Class
-#include "../detail/ContainerNavigatorBase.h"
+#include "../detail/ContainerVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class ListNavigator;
- typedef std::shared_ptr<ListNavigator> ListNavigatorPtr;
-
- class ListNavigator :
- virtual public detail::ContainerNavigatorBase<type::AronList, ListNavigator>
+ /**
+ * @brief The List class. It represents the list type
+ * It only has an accepted type (a variant)
+ */
+ class List :
+ public detail::ContainerVariant<type::dto::List, List>
{
public:
// constructors
- ListNavigator(const Path& path = Path());
- ListNavigator(const type::AronListPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const ListNavigator&) const override;
+ List(const VariantPtr& acceptedType, const Path& path = Path());
+ List(const type::dto::List&, const Path& path = Path());
// public member functions
- NavigatorPtr getAcceptedType() const;
- void setAcceptedType(const NavigatorPtr&);
+ VariantPtr getAcceptedType() const;
+ void setAcceptedType(const VariantPtr&);
- type::AronListPtr toAronListPtr() const;
+ type::dto::ListPtr toListDTO() const;
// virtual implementations
- std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ std::vector<VariantPtr> getChildren() const override;
+ size_t childrenSize() const override;
private:
// members
- NavigatorPtr acceptedType;
+ VariantPtr acceptedType;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Object.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
similarity index 54%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Object.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
index d5e028477cb93837e70cedf95d321652e8a14db6..a6e61b8866e15a194126a9fbf0161f2ba32a9f71 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Object.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
@@ -29,55 +29,43 @@
#include <SimoxUtility/algorithm/string/string_conversion.h>
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- ObjectNavigator::ObjectNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eObject, path)
- {
- }
-
- ObjectNavigator::ObjectNavigator(const std::string& name, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eObject, path)
+ Object::Object(const std::string& name, const std::map<std::string, VariantPtr>& m, const Path& path) :
+ detail::ContainerVariant<type::dto::AronObject, Object>(type::Descriptor::eObject, path),
+ memberTypes(m)
{
setObjectName(name);
- }
-
- ObjectNavigator::ObjectNavigator(const type::AronObjectPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eObject, path),
- detail::NavigatorBase<type::AronObject, ObjectNavigator>(o)
- {
- for (const auto& [key, t] : o->elementTypes)
+ for (const auto& [key, value] : memberTypes)
{
- memberTypes[key] = FromAronType(t);
+ aron->elementTypes[key] = value->toAronDTO();
}
}
- // operators
- bool ObjectNavigator::operator==(const ObjectNavigator& other) const
+ Object::Object(const type::dto::AronObject& o, const Path& path) :
+ detail::ContainerVariant<type::dto::AronObject, Object>(o, type::Descriptor::eObject, path)
{
- if (getMaybe() != other.getMaybe())
+ for (const auto& [key, t] : o.elementTypes)
{
- return false;
+ memberTypes[key] = FromAronDTO(*t);
}
-
- return getObjectName() == other.getObjectName();
}
- bool ObjectNavigator::checkObjectName(const std::string& s) const
+ bool Object::checkObjectName(const std::string& s) const
{
if (s.empty())
{
- throw error::AronException("ObjectNavigator", "getResult", "The object name is empty.", getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "The object name is empty.", getPath());
}
return true;
}
// public member functions
- std::map<std::string, NavigatorPtr> ObjectNavigator::getAllMemberTypes() const
+ std::map<std::string, VariantPtr> Object::getMemberTypes() const
{
- std::map<std::string, NavigatorPtr> ret = memberTypes;
+ std::map<std::string, VariantPtr> ret = memberTypes;
if (extends)
{
for (const auto& [key, t] : extends->getMemberTypes())
@@ -88,16 +76,16 @@ namespace armarx::aron::typenavigator
return ret;
}
- std::map<std::string, NavigatorPtr> ObjectNavigator::getMemberTypes() const
+ std::map<std::string, VariantPtr> Object::getDirectMemberTypes() const
{
return memberTypes;
}
- NavigatorPtr ObjectNavigator::getMemberType(const std::string& s) const
+ VariantPtr Object::getMemberType(const std::string& s) const
{
if (memberTypes.find(s) == memberTypes.end() and !extends->hasMemberType(s))
{
- throw error::StringNotValidException("ObjectNavigator", "getMemberType", "Member not set. The list of all members is: " + simox::alg::to_string(simox::alg::get_keys(memberTypes)), s);
+ throw error::ValueNotValidException("ObjectNavigator", "getMemberType", "Member not set. The list of all members is: " + simox::alg::to_string(simox::alg::get_keys(memberTypes)), s);
}
if (memberTypes.find(s) == memberTypes.end())
{
@@ -106,49 +94,49 @@ namespace armarx::aron::typenavigator
return memberTypes.at(s);
}
- void ObjectNavigator::addMemberType(const std::string& k, const NavigatorPtr& v)
+ void Object::addMemberType(const std::string& k, const VariantPtr& v)
{
if (k.empty())
{
- throw error::AronException("ObjectNavigator", "addAcceptedType", "Cannot set an element with an empty key.", getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "Cannot set an element with an empty key.", getPath());
}
ARMARX_CHECK_NOT_NULL(v);
- this->aron->elementTypes[k] = v->toAronTypePtr();
+ this->aron->elementTypes[k] = v->toAronDTO();
memberTypes[k] = v;
}
- void ObjectNavigator::setObjectName(const std::string& n)
+ void Object::setObjectName(const std::string& n)
{
//path.setRootIdentifier(n);
this->aron->objectName = n;
}
- void ObjectNavigator::setExtends(const ObjectNavigatorPtr& p)
+ void Object::setExtends(const std::shared_ptr<Object>& p)
{
ARMARX_CHECK_NOT_NULL(p);
- type::AronObjectPtr ex = p->toAronObjectPtr();
+ type::dto::AronObjectPtr ex = p->toObjectDTO();
ARMARX_CHECK_NOT_NULL(ex);
extends = p;
}
- bool ObjectNavigator::hasMemberType(const std::string& k) const
+ bool Object::hasMemberType(const std::string& k) const
{
return memberTypes.count(k) > 0 or (extends && extends->hasMemberType(k));
}
- std::string ObjectNavigator::getObjectName() const
+ std::string Object::getObjectName() const
{
return this->aron->objectName;
}
- ObjectNavigatorPtr ObjectNavigator::getExtends() const
+ std::shared_ptr<Object> Object::getExtends() const
{
return extends;
}
- std::vector<std::string> ObjectNavigator::getAllKeys() const
+ std::vector<std::string> Object::getAllKeys() const
{
std::vector<std::string> ret;
for (const auto& [k, _] : memberTypes)
@@ -165,7 +153,7 @@ namespace armarx::aron::typenavigator
return ret;
}
- type::AronObjectPtr ObjectNavigator::toAronObjectPtr() const
+ type::dto::AronObjectPtr Object::toObjectDTO() const
{
// TODO: Shall we allow empty objects?
//if(acceptedTypeNavigators.empty())
@@ -176,9 +164,9 @@ namespace armarx::aron::typenavigator
}
// virtual implementations
- std::vector<NavigatorPtr> ObjectNavigator::getChildren() const
+ std::vector<VariantPtr> Object::getChildren() const
{
- std::vector<NavigatorPtr> ret;
+ std::vector<VariantPtr> ret;
for (const auto& [k, t] : memberTypes)
{
ret.push_back(t);
@@ -193,14 +181,19 @@ namespace armarx::aron::typenavigator
return ret;
}
- size_t ObjectNavigator::childrenSize() const
+ size_t Object::childrenSize() const
{
return memberTypes.size();
}
- std::string ObjectNavigator::getName() const
+ std::string Object::getShortName() const
+ {
+ return "Object<" + this->aron->objectName + (extends ? (" : " + extends->getShortName()) : "") + ">";
+ }
+
+ std::string Object::getFullName() const
{
- return "AronObjectType<" + this->aron->objectName + (extends ? (" : " + extends->getName()) : "") + ">";
+ return "armarx::aron::type::Object<" + this->aron->objectName + (extends ? (" : " + extends->getFullName()) : "") + ">";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Object.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
similarity index 51%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Object.h
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
index 71268a91ebf928b13a1347c778f758c43e756ace..fcd20e561e25b6d356302400584142ba97713c41 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Object.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
@@ -28,53 +28,54 @@
#include <map>
// Base Class
-#include "../detail/ContainerNavigatorBase.h"
+#include "../detail/ContainerVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class ObjectNavigator;
- typedef std::shared_ptr<ObjectNavigator> ObjectNavigatorPtr;
+ class Object;
+ using ObjectPtr = std::shared_ptr<Object>;
- class ObjectNavigator :
- virtual public detail::ContainerNavigatorBase<type::AronObject, ObjectNavigator>
+ /**
+ * @brief The Object class. It represents the object type
+ * An object may have different types for each member, here represented as a map, mapping from the member name (as string) to the type (as a variant)
+ */
+ class Object :
+ public detail::ContainerVariant<type::dto::AronObject, Object>
{
public:
// constructors
- ObjectNavigator(const Path& = Path());
- ObjectNavigator(const std::string&, const Path& = Path());
- ObjectNavigator(const type::AronObjectPtr&, const Path& = Path());
-
- // operators
- virtual bool operator==(const ObjectNavigator&) const override;
+ Object(const std::string&, const std::map<std::string, VariantPtr>&, const Path& = Path());
+ Object(const type::dto::AronObject&, const Path& = Path());
// public member functions
bool checkObjectName(const std::string&) const;
- std::map<std::string, NavigatorPtr> getAllMemberTypes() const;
- std::map<std::string, NavigatorPtr> getMemberTypes() const;
- NavigatorPtr getMemberType(const std::string&) const;
+ std::map<std::string, VariantPtr> getMemberTypes() const;
+ std::map<std::string, VariantPtr> getDirectMemberTypes() const;
+ VariantPtr getMemberType(const std::string&) const;
std::string getObjectName() const;
- ObjectNavigatorPtr getExtends() const;
+ std::shared_ptr<Object> getExtends() const;
void setObjectName(const std::string&);
- void setExtends(const ObjectNavigatorPtr&);
- void addMemberType(const std::string&, const NavigatorPtr&);
+ void setExtends(const std::shared_ptr<Object>&);
+ void addMemberType(const std::string&, const VariantPtr&);
bool hasMemberType(const std::string&) const;
std::vector<std::string> getAllKeys() const;
- type::AronObjectPtr toAronObjectPtr() const;
+ type::dto::AronObjectPtr toObjectDTO() const;
// virtual implementations
- std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ std::vector<VariantPtr> getChildren() const override;
+ size_t childrenSize() const override;
private:
// members
- ObjectNavigatorPtr extends;
- std::map<std::string, NavigatorPtr> memberTypes;
+ std::shared_ptr<Object> extends;
+ std::map<std::string, VariantPtr> memberTypes;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
similarity index 51%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
index f9a2f4bd4a2a2d47e298ee12f3ee0def45edd0ba..c8bdeaf653ceaf6d67f87637de6d65bc4652fb37 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Pair.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
@@ -25,50 +25,42 @@
#include "Pair.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- PairNavigator::PairNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePair, path)
+ Pair::Pair(const VariantPtr& acceptedType1, const VariantPtr& acceptedType2, const Path& path) :
+ detail::ContainerVariant<type::dto::Pair, Pair>(type::Descriptor::ePair, path),
+ acceptedType1(acceptedType1),
+ acceptedType2(acceptedType2)
{
-
+ aron->acceptedType1 = acceptedType1->toAronDTO();
+ aron->acceptedType2 = acceptedType2->toAronDTO();
}
- PairNavigator::PairNavigator(const type::AronPairPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePair, path),
- detail::NavigatorBase<type::AronPair, PairNavigator>(o),
- acceptedType1(FromAronType(o->acceptedType1)),
- acceptedType2(FromAronType(o->acceptedType2))
+ Pair::Pair(const type::dto::Pair& o, const Path& path) :
+ detail::ContainerVariant<type::dto::Pair, Pair>(o, type::Descriptor::ePair, path),
+ acceptedType1(FromAronDTO(*o.acceptedType1)),
+ acceptedType2(FromAronDTO(*o.acceptedType2))
{
}
- // operators
- bool PairNavigator::operator==(const PairNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getFirstAcceptedType() == other.getFirstAcceptedType() && getSecondAcceptedType() == other.getSecondAcceptedType();
- }
-
// Member functions
- std::pair<NavigatorPtr, NavigatorPtr> PairNavigator::getAcceptedTypes() const
+ std::pair<VariantPtr, VariantPtr> Pair::getAcceptedTypes() const
{
return {acceptedType1, acceptedType2};
}
- NavigatorPtr PairNavigator::getFirstAcceptedType() const
+ VariantPtr Pair::getFirstAcceptedType() const
{
return acceptedType1;
}
- NavigatorPtr PairNavigator::getSecondAcceptedType() const
+ VariantPtr Pair::getSecondAcceptedType() const
{
return acceptedType2;
}
- void PairNavigator::addAcceptedType(const NavigatorPtr& n)
+ void Pair::addAcceptedType(const VariantPtr& n)
{
ARMARX_CHECK_NOT_NULL(n);
@@ -82,40 +74,45 @@ namespace armarx::aron::typenavigator
acceptedType2 = n;
return;
}
- throw error::AronException("PairNavigator", "addAcceptedType", "Both types are already set", getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "Both types are already set", getPath());
}
- void PairNavigator::setFirstAcceptedType(const NavigatorPtr& n)
+ void Pair::setFirstAcceptedType(const VariantPtr& n)
{
ARMARX_CHECK_NOT_NULL(n);
acceptedType1 = n;
}
- void PairNavigator::setSecondAcceptedType(const NavigatorPtr& n)
+ void Pair::setSecondAcceptedType(const VariantPtr& n)
{
ARMARX_CHECK_NOT_NULL(n);
acceptedType2 = n;
}
- type::AronPairPtr PairNavigator::toAronPairPtr() const
+ type::dto::PairPtr Pair::toPairDTO() const
{
return this->aron;
}
// virtual implementations
- std::vector<NavigatorPtr> PairNavigator::getChildren() const
+ std::vector<VariantPtr> Pair::getChildren() const
{
return {acceptedType1, acceptedType2};
}
- size_t PairNavigator::childrenSize() const
+ size_t Pair::childrenSize() const
{
return 2;
}
- std::string PairNavigator::getName() const
+ std::string Pair::getShortName() const
+ {
+ return "Pair<" + acceptedType1->getShortName() + ", " + acceptedType2->getShortName() + ">";
+ }
+
+ std::string Pair::getFullName() const
{
- return "AronPairType<" + acceptedType1->getName() + ", " + acceptedType2->getName() + ">";
+ return "armarx::aron::type::Pair<" + acceptedType1->getFullName() + ", " + acceptedType2->getFullName() + ">";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
index 60665e7d41d2e2120badc3de60b9e84067fbf215..7a987e304b145316cab6b4d55dbe03322ad4a264 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
@@ -28,37 +28,42 @@
#include <map>
// Base Class
-#include "../detail/ContainerNavigatorBase.h"
+#include "../detail/ContainerVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class TupleNavigator;
- typedef std::shared_ptr<TupleNavigator> TupleNavigatorPtr;
-
- class TupleNavigator :
- virtual public detail::ContainerNavigatorBase<type::AronTuple, TupleNavigator>
+ /**
+ * @brief The Pair class. It represents the pair type
+ * A pair has two accepted types
+ */
+ class Pair :
+ public detail::ContainerVariant<type::dto::Pair, Pair>
{
public:
// constructors
- TupleNavigator(const Path& path = Path());
- TupleNavigator(const type::AronTuplePtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const TupleNavigator&) const override;
+ Pair(const VariantPtr& acceptedType1, const VariantPtr& acceptedType2, const Path& path = Path());
+ Pair(const type::dto::Pair&, const Path& path = Path());
// public member functions
- std::vector<NavigatorPtr> getAcceptedTypes() const;
- NavigatorPtr getAcceptedType(unsigned int i) const;
- void addAcceptedType(const NavigatorPtr&);
+ std::pair<VariantPtr, VariantPtr> getAcceptedTypes() const;
+ VariantPtr getFirstAcceptedType() const;
+ VariantPtr getSecondAcceptedType() const;
+ void addAcceptedType(const VariantPtr&);
+ void setFirstAcceptedType(const VariantPtr&);
+ void setSecondAcceptedType(const VariantPtr&);
- type::AronTuplePtr toAronTuplePtr() const;
+ type::dto::PairPtr toPairDTO() const;
// virtual implementations
- std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ std::vector<VariantPtr> getChildren() const override;
+ size_t childrenSize() const override;
private:
- std::vector<NavigatorPtr> acceptedTypes;
+ // members
+ VariantPtr acceptedType1;
+ VariantPtr acceptedType2;
+
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
index bded16377622e363c07fd5007de86349d2248a11..781291eccb8f9e93173ed5bc3108b9bd5fd70572 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
@@ -26,89 +26,84 @@
#include <SimoxUtility/algorithm/string/string_conversion.h>
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- TupleNavigator::TupleNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path)
+ Tuple::Tuple(const std::vector<VariantPtr>& acceptedTypes, const Path& path) :
+ detail::ContainerVariant<type::dto::Tuple, Tuple>(type::Descriptor::eTuple, path),
+ acceptedTypes(acceptedTypes)
{
- }
-
- TupleNavigator::TupleNavigator(const type::AronTuplePtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path),
- detail::NavigatorBase<type::AronTuple, TupleNavigator>(o)
- {
- for (const auto& t : this->aron->elementTypes)
+ for (const auto& acceptedType : acceptedTypes)
{
- acceptedTypes.push_back(FromAronType(t));
+ aron->elementTypes.push_back(acceptedType->toAronDTO());
}
}
- // operators
- bool TupleNavigator::operator==(const TupleNavigator& other) const
+ Tuple::Tuple(const type::dto::Tuple& o, const Path& path) :
+ detail::ContainerVariant<type::dto::Tuple, Tuple>(o, type::Descriptor::eTuple, path)
{
- if (getMaybe() != other.getMaybe())
+ for (const auto& t : o.elementTypes)
{
- return false;
+ acceptedTypes.push_back(FromAronDTO(*t));
}
-
- unsigned int i = 0;
- for (const auto& nav : acceptedTypes)
- {
- if (nav != other.getAcceptedType(i++))
- {
- return false;
- }
- }
- return true;
}
- type::AronTuplePtr TupleNavigator::toAronTuplePtr() const
+ type::dto::TuplePtr Tuple::toTupleDTO() const
{
if (acceptedTypes.empty())
{
- throw error::AronException("TupleNavigator", "getCastedResult", "No accepted types set", getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "No accepted types set", getPath());
}
return this->aron;
}
// public member functions
- std::vector<NavigatorPtr> TupleNavigator::getAcceptedTypes() const
+ std::vector<VariantPtr> Tuple::getAcceptedTypes() const
{
return acceptedTypes;
}
- NavigatorPtr TupleNavigator::getAcceptedType(unsigned int i) const
+ VariantPtr Tuple::getAcceptedType(unsigned int i) const
{
return acceptedTypes[i];
}
- void TupleNavigator::addAcceptedType(const NavigatorPtr& v)
+ void Tuple::addAcceptedType(const VariantPtr& v)
{
ARMARX_CHECK_NOT_NULL(v);
- this->aron->elementTypes.push_back(v->toAronTypePtr());
+ this->aron->elementTypes.push_back(v->toAronDTO());
acceptedTypes.push_back(v);
}
// virtual implementations
- std::vector<NavigatorPtr> TupleNavigator::getChildren() const
+ std::vector<VariantPtr> Tuple::getChildren() const
{
return acceptedTypes;
}
- size_t TupleNavigator::childrenSize() const
+ size_t Tuple::childrenSize() const
{
return acceptedTypes.size();
}
- std::string TupleNavigator::getName() const
+ std::string Tuple::getShortName() const
+ {
+ std::vector<std::string> names;
+ for (const auto& n : acceptedTypes)
+ {
+ names.push_back(n->getShortName());
+ }
+ return "Tuple<" + simox::alg::to_string(names, ", ") + ">";
+ }
+
+ std::string Tuple::getFullName() const
{
std::vector<std::string> names;
for (const auto& n : acceptedTypes)
{
- names.push_back(n->getName());
+ names.push_back(n->getFullName());
}
- return "AronTupleType<" + simox::alg::to_string(names, ", ") + ">";
+ return "armarx::aron::type::Tuple<" + simox::alg::to_string(names, ", ") + ">";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0096397073110d8bdbaa7eff9531c1c2f000145
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
@@ -0,0 +1,63 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+#include <map>
+
+// Base Class
+#include "../detail/ContainerVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The Tuple class. It represents the tuple type
+ * A tuple has a list of accepted types
+ */
+ class Tuple :
+ public detail::ContainerVariant<type::dto::Tuple, Tuple>
+ {
+ public:
+ // constructors
+ Tuple(const std::vector<VariantPtr>& acceptedTypes, const Path& path = Path());
+ Tuple(const type::dto::Tuple&, const Path& path = Path());
+
+ // public member functions
+ std::vector<VariantPtr> getAcceptedTypes() const;
+ VariantPtr getAcceptedType(unsigned int i) const;
+ void addAcceptedType(const VariantPtr&);
+
+ type::dto::TuplePtr toTupleDTO() const;
+
+ // virtual implementations
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ std::vector<VariantPtr> getChildren() const override;
+ size_t childrenSize() const override;
+
+ private:
+ std::vector<VariantPtr> acceptedTypes;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.cpp b/source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90c59644028f31b2d2d340fcc4adac1444e77804
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.h b/source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.h
similarity index 78%
rename from source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.h
index e1b60ff4005f5aa59a3d88c89508ddbe26d374f5..2673250f8fdda3fd234f2e7174433af45eda5bea 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/ContainerNavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/ContainerVariant.h
@@ -29,23 +29,18 @@
#include <unordered_map>
// Base class
-#include "NavigatorBase.h"
+#include "SpecializedVariant.h"
// ArmarX
-namespace armarx::aron::typenavigator::detail
+namespace armarx::aron::type::detail
{
template<typename AronTypeT, typename DerivedT>
- class ContainerNavigatorBase :
- virtual public NavigatorBase<AronTypeT, DerivedT>
+ class ContainerVariant :
+ public SpecializedVariantBase<AronTypeT, DerivedT>
{
public:
- ContainerNavigatorBase() {}
-
- // virtual implementations
-
- // static methods
-
- /* public member functions */
+ using SpecializedVariantBase<AronTypeT, DerivedT>::SpecializedVariantBase;
+ virtual ~ContainerVariant() = default;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.cpp b/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90c59644028f31b2d2d340fcc4adac1444e77804
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.h b/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.h
new file mode 100644
index 0000000000000000000000000000000000000000..eaa1924c1e5204e224f2a485afbcb174acc52d1f
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/EnumVariant.h
@@ -0,0 +1,57 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+// Base class
+#include "SpecializedVariant.h"
+
+// ArmarX
+
+namespace armarx::aron::type::detail
+{
+ template<typename AronTypeT, typename DerivedT>
+ class EnumVariant :
+ public SpecializedVariantBase<AronTypeT, DerivedT>
+ {
+ public:
+ using SpecializedVariantBase<AronTypeT, DerivedT>::SpecializedVariantBase;
+
+ virtual ~EnumVariant() = default;
+
+ std::vector<VariantPtr> getChildren() const override
+ {
+ return {};
+ }
+
+ size_t childrenSize() const override
+ {
+ return 0;
+ }
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.cpp b/source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90c59644028f31b2d2d340fcc4adac1444e77804
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.h b/source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.h
similarity index 76%
rename from source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.h
index 7beb2256a8671ff008bdef2d244f1e635fac17e5..cef80f77c690ea823fdb3ee9d1c3f28c9097cbbd 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NDArrayNavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/NDArrayVariant.h
@@ -29,25 +29,27 @@
#include <unordered_map>
// Base class
-#include "NavigatorBase.h"
+#include "SpecializedVariant.h"
// ArmarX
-namespace armarx::aron::typenavigator::detail
+namespace armarx::aron::type::detail
{
template<typename AronTypeT, typename DerivedT>
- class NDArrayNavigatorBase :
- virtual public NavigatorBase<AronTypeT, DerivedT>
+ class NDArrayVariant :
+ public SpecializedVariantBase<AronTypeT, DerivedT>
{
public:
- NDArrayNavigatorBase() {};
+ using SpecializedVariantBase<AronTypeT, DerivedT>::SpecializedVariantBase;
+
+ virtual ~NDArrayVariant() = default;
/* virtual implementations */
- virtual std::vector<NavigatorPtr> getChildren() const override
+ std::vector<VariantPtr> getChildren() const override
{
return {};
}
- virtual size_t childrenSize() const override
+ size_t childrenSize() const override
{
return 0;
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.cpp b/source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90c59644028f31b2d2d340fcc4adac1444e77804
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PrimitiveVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.h b/source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.h
index a73fbcbd1c0f3556f623ef759d3f2552f1376128..4c729aed09aa8e01caeda41b68e79568b18f95bb 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/PrimitiveNavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/PrimitiveVariant.h
@@ -29,31 +29,27 @@
#include <unordered_map>
// Base class
-#include "NavigatorBase.h"
+#include "SpecializedVariant.h"
// ArmarX
-namespace armarx::aron::typenavigator::detail
+namespace armarx::aron::type::detail
{
- template<typename AronDataT, typename DerivedT>
- class PrimitiveNavigatorBase :
- virtual public NavigatorBase<AronDataT, DerivedT>
+ template<typename AronTypeT, typename DerivedT>
+ class PrimitiveVariant :
+ public SpecializedVariantBase<AronTypeT, DerivedT>
{
public:
- PrimitiveNavigatorBase() {};
+ using SpecializedVariantBase<AronTypeT, DerivedT>::SpecializedVariantBase;
- // operators
- virtual bool operator==(const DerivedT& other) const override
- {
- return this->getMaybe() == other.getMaybe();
- }
+ virtual ~PrimitiveVariant() = default;
/* virtual implementations */
- virtual std::vector<NavigatorPtr> getChildren() const override
+ std::vector<VariantPtr> getChildren() const override
{
return {};
}
- virtual size_t childrenSize() const override
+ size_t childrenSize() const override
{
return 0;
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.cpp b/source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..615d60bbb765c9f9c586abe5ad9f0b0f269a5d70
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.cpp
@@ -0,0 +1,25 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "SpecializedVariant.h"
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.h b/source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.h
similarity index 58%
rename from source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.h
rename to source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.h
index 055b1d3b68b14956bc65281bfc38030773baf5c9..06bae251e9f9e2f032ce513eab2a5d236599c0b6 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/detail/NavigatorBase.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/detail/SpecializedVariant.h
@@ -29,64 +29,51 @@
#include <unordered_map>
// Base class
-#include "../Navigator.h"
+#include "../Variant.h"
// ArmarX
-namespace armarx::aron::typenavigator::detail
+namespace armarx::aron::type::detail
{
template<typename AronTypeT, typename DerivedT>
- class NavigatorBase :
- virtual public typenavigator::Navigator
+ class SpecializedVariantBase :
+ public type::Variant
{
- public:
- using PointerType = std::shared_ptr<DerivedT>;
- using AronType = AronTypeT;
public:
- NavigatorBase() :
+ SpecializedVariantBase(const type::Descriptor& descriptor, const Path& path) :
+ Variant(descriptor, path),
aron(new AronTypeT())
{
}
- NavigatorBase(const typename AronType::PointerType& o) :
- aron(new AronTypeT(*o))
+ SpecializedVariantBase(const AronTypeT& o, const type::Descriptor& descriptor, const Path& path) :
+ Variant(descriptor, path),
+ aron(new AronTypeT(o))
{
- ARMARX_CHECK_NOT_NULL(aron);
}
+ virtual ~SpecializedVariantBase() = default;
+
// operators
- operator typename AronType::PointerType()
+ operator AronTypeT()
{
- return aron;
+ return *aron;
}
- virtual bool operator==(const Navigator& other) const override
+ bool operator==(const Variant& other) const override
{
- const auto& n = DerivedT::DynamicCast(other);
+ const auto& n = dynamic_cast<const DerivedT&>(other);
return *this == n;
}
- virtual bool operator==(const NavigatorPtr& other) const override
- {
- if (!other)
- {
- return false;
- }
- return *this == *other;
- }
- virtual bool operator==(const DerivedT&) const = 0;
- bool operator==(const PointerType& other) const
+ bool operator==(const DerivedT& other) const
{
- if (other)
- {
- return *this == *other;
- }
- return false;
+ return *(this->aron) == *(other.aron);
}
// virtual implementations
- virtual type::AronTypePtr toAronPtr() const override
+ type::dto::GenericTypePtr toAronDTO() const override
{
ARMARX_CHECK_NOT_NULL(aron);
return aron;
@@ -102,30 +89,30 @@ namespace armarx::aron::typenavigator::detail
}
// static methods
- static PointerType DynamicCast(const NavigatorPtr& n)
+ static DerivedT& DynamicCast(Variant& n)
{
- return std::dynamic_pointer_cast<DerivedT>(n);
+ return dynamic_cast<DerivedT&>(n);
}
- static DerivedT& DynamicCast(Navigator& n)
+ static const DerivedT& DynamicCast(const Variant& n)
{
- return dynamic_cast<DerivedT&>(n);
+ return dynamic_cast<const DerivedT&>(n);
}
- static const DerivedT& DynamicCast(const Navigator& n)
+ static std::shared_ptr<DerivedT> DynamicCast(const VariantPtr& n)
{
- return dynamic_cast<const DerivedT&>(n);
+ return std::dynamic_pointer_cast<DerivedT>(n);
}
- static PointerType DynamicCastAndCheck(const NavigatorPtr& n)
+ static std::shared_ptr<DerivedT> DynamicCastAndCheck(const VariantPtr& n)
{
ARMARX_CHECK_NOT_NULL(n);
- auto casted = DerivedT::DynamicCast(n);
+ auto casted = std::dynamic_pointer_cast<DerivedT>(n);
ARMARX_CHECK_NOT_NULL(casted);
return casted;
}
protected:
- typename AronType::PointerType aron;
+ typename AronTypeT::PointerType aron;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/enum/All.h b/source/RobotAPI/libraries/aron/core/type/variant/enum/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0cd4bc3b65639932a53e0332969eeaa41da3b8c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/enum/All.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "IntEnum.h"
+
+/**
+ * A convenience header to include all enum aron files (full include, not forward declared)
+ */
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp b/source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.cpp
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.cpp
index 0e3f0594bb085b991fda4a66acf3877b5590a550..734509d9e3272271c0ca3baece597c6e5b1b8d7a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.cpp
@@ -24,36 +24,27 @@
// Header
#include "IntEnum.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- IntEnumNavigator::IntEnumNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eIntEnum, path)
+ IntEnum::IntEnum(const std::string& name, const std::map<std::string, int>& valueMap, const Path& path) :
+ detail::EnumVariant<type::dto::IntEnum, IntEnum>(type::Descriptor::eIntEnum, path)
{
+ aron->enumName = name;
+ aron->acceptedValues = valueMap;
}
- IntEnumNavigator::IntEnumNavigator(const type::AronIntEnumPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eIntEnum, path),
- detail::NavigatorBase<type::AronIntEnum, IntEnumNavigator>(o)
+ IntEnum::IntEnum(const type::dto::IntEnum& o, const Path& path) :
+ detail::EnumVariant<type::dto::IntEnum, IntEnum>(o, type::Descriptor::eIntEnum, path)
{
}
- // operators
- bool IntEnumNavigator::operator==(const IntEnumNavigator& other) const
- {
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return getEnumName() == other.getEnumName();
- }
-
- std::map<std::string, int> IntEnumNavigator::getAcceptedValueMap() const
+ std::map<std::string, int> IntEnum::getAcceptedValueMap() const
{
return this->aron->acceptedValues;
}
- std::vector<std::string> IntEnumNavigator::getAcceptedValueNames() const
+ std::vector<std::string> IntEnum::getAcceptedValueNames() const
{
std::vector<std::string> names;
for (const auto& [k, _] : aron->acceptedValues)
@@ -63,7 +54,7 @@ namespace armarx::aron::typenavigator
return names;
}
- std::vector<int> IntEnumNavigator::getAcceptedValues() const
+ std::vector<int> IntEnum::getAcceptedValues() const
{
std::vector<int> vals;
for (const auto& [_, i] : aron->acceptedValues)
@@ -73,7 +64,7 @@ namespace armarx::aron::typenavigator
return vals;
}
- std::string IntEnumNavigator::getValueName(int i) const
+ std::string IntEnum::getValueName(int i) const
{
for (const auto& [k, v] : this->aron->acceptedValues)
{
@@ -82,46 +73,43 @@ namespace armarx::aron::typenavigator
return k;
}
}
- throw error::AronException("IntEnumNavigator", "getValueName", "Enum could not be resolved. Input was: " + std::to_string(i), getPath());
+ throw error::AronException(__PRETTY_FUNCTION__, "Enum could not be resolved. Input was: " + std::to_string(i), getPath());
}
- int IntEnumNavigator::getValue(const std::string& s) const
+ int IntEnum::getValue(const std::string& s) const
{
return this->aron->acceptedValues[s];
}
- std::string IntEnumNavigator::getEnumName() const
+ std::string IntEnum::getEnumName() const
{
return this->aron->enumName;
}
- void IntEnumNavigator::setEnumName(const std::string& s)
+ void IntEnum::setEnumName(const std::string& s)
{
this->aron->enumName = s;
}
- void IntEnumNavigator::addAcceptedValue(const std::string& s, int i)
+ void IntEnum::addAcceptedValue(const std::string& s, int i)
{
this->aron->acceptedValues[s] = i;
}
- type::AronIntEnumPtr IntEnumNavigator::toAronIntEnumPtr() const
+ type::dto::IntEnumPtr IntEnum::toIntEnumDTO() const
{
return this->aron;
}
// virtual implementations
- std::string IntEnumNavigator::getName() const
- {
- return "AronIntEnumType";
- }
- std::vector<NavigatorPtr> IntEnumNavigator::getChildren() const
+ std::string IntEnum::getShortName() const
{
- return {};
+ return "IntEnum";
}
- size_t IntEnumNavigator::childrenSize() const
+
+ std::string IntEnum::getFullName() const
{
- return 0;
+ return "armarx::aron::type::IntEnum";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h b/source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h
similarity index 67%
rename from source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h
rename to source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h
index 31ccdab0ddecf016b9eaf67a5af5941e65d6a272..cf652d23cfb225d1ba4efde9c7d48af7c0e34966 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h
@@ -28,23 +28,24 @@
#include <map>
// Base class
-#include "../detail/NavigatorBase.h"
+#include "../detail/EnumVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class IntEnumNavigator;
- typedef std::shared_ptr<IntEnumNavigator> IntEnumNavigatorPtr;
+ class IntEnum;
+ using IntEnumPtr = std::shared_ptr<IntEnum>;
- class IntEnumNavigator :
- virtual public detail::NavigatorBase<type::AronIntEnum, IntEnumNavigator>
+ /**
+ * @brief The IntEnum class. It represents the int enum type
+ * An int enum contains a map from strings to int values
+ */
+ class IntEnum :
+ public detail::EnumVariant<type::dto::IntEnum, IntEnum>
{
public:
// constructors
- IntEnumNavigator(const Path& path = Path());
- IntEnumNavigator(const type::AronIntEnumPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const IntEnumNavigator&) const override;
+ IntEnum(const std::string& name, const std::map<std::string, int>& valueMap, const Path& path = Path());
+ IntEnum(const type::dto::IntEnum&, const Path& path = Path());
// public member functions
std::map<std::string, int> getAcceptedValueMap() const;
@@ -58,11 +59,10 @@ namespace armarx::aron::typenavigator
void setEnumName(const std::string&);
void addAcceptedValue(const std::string&, int);
- type::AronIntEnumPtr toAronIntEnumPtr() const;
+ type::dto::IntEnumPtr toIntEnumDTO() const;
// virtual implementations
- virtual std::string getName() const override;
- virtual std::vector<NavigatorPtr> getChildren() const override;
- virtual size_t childrenSize() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a04a310f3b8268d5d3223fe7f602d8c27cf055b
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+/**
+ * forward declarations of ALL aron type objects
+ */
+namespace armarx::aron::type
+{
+ class Variant;
+ using VariantPtr = std::shared_ptr<Variant>;
+
+ using DictPtr = std::shared_ptr<class Dict>;
+ using ListPtr = std::shared_ptr<class List>;
+ using ObjectPtr = std::shared_ptr<class Object>;
+ using PairPtr = std::shared_ptr<class Pair>;
+ using TuplePtr = std::shared_ptr<class Tuple>;
+
+ using PosePtr = std::shared_ptr<class Pose>;
+ using NDArrayPtr = std::shared_ptr<class NDArray>;
+ using MatrixPtr = std::shared_ptr<class Matrix>;
+ using QuaternionPtr = std::shared_ptr<class Quaternion>;
+ using ImagePtr = std::shared_ptr<class Image>;
+ using OrientationPtr = std::shared_ptr<class Orientation>;
+ using PointCloudPtr = std::shared_ptr<class PointCloud>;
+ using PositionPtr = std::shared_ptr<class Position>;
+
+ using IntEnumPtr = std::shared_ptr<class IntEnum>;
+
+ using IntPtr = std::shared_ptr<class Int>;
+ using LongPtr = std::shared_ptr<class Long>;
+ using FloatPtr = std::shared_ptr<class Float>;
+ using DoublePtr = std::shared_ptr<class Double>;
+ using StringPtr = std::shared_ptr<class String>;
+ using BoolPtr = std::shared_ptr<class Bool>;
+ using TimePtr = std::shared_ptr<class Time>;
+
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/All.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..0830c044a80e09cc51301e6de8718c7cc931b743
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/All.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "NDArray.h"
+#include "Matrix.h"
+#include "Quaternion.h"
+#include "Image.h"
+#include "Orientation.h"
+#include "PointCloud.h"
+#include "Pose.h"
+#include "Position.h"
+
+/**
+ * A convenience header to include all ndarray aron files (full include, not forward declared)
+ */
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.cpp
similarity index 74%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.cpp
index bc09aaf12feb336eddd479ccfebb3b000dd1980d..59b6ce80320bad3a197e74b6251cba0c8b1c209c 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.cpp
@@ -20,7 +20,7 @@
* @copyright http://www.gnu.org/licenses/gpl-2.0.txt
* GNU General Public License
*/
-
+/*
// Header
#include "IVTCByteImage.h"
@@ -28,13 +28,13 @@ namespace armarx::aron::typenavigator
{
// constructors
IVTCByteImageNavigator::IVTCByteImageNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eIVTCByteImage, path)
+ aron::Navigator<type::Descriptor, type::dto::GenericType>::Navigator(type::Descriptor::eIVTCByteImage, path)
{
}
- IVTCByteImageNavigator::IVTCByteImageNavigator(const type::AronIVTCByteImagePtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eIVTCByteImage, path),
- detail::NavigatorBase<type::AronIVTCByteImage, IVTCByteImageNavigator>(o)
+ IVTCByteImageNavigator::IVTCByteImageNavigator(const type::dto::AronIVTCByteImagePtr& o, const Path& path) :
+ aron::Navigator<type::Descriptor, type::dto::GenericType>::Navigator(type::Descriptor::eIVTCByteImage, path),
+ detail::NavigatorBase<type::dto::AronIVTCByteImage, IVTCByteImageNavigator>(o)
{
}
@@ -48,7 +48,7 @@ namespace armarx::aron::typenavigator
return true;
}
- type::AronIVTCByteImagePtr IVTCByteImageNavigator::toAronIVTCByteImagePtr() const
+ type::dto::AronIVTCByteImagePtr IVTCByteImageNavigator::toAronIVTCByteImagePtr() const
{
return this->aron;
}
@@ -58,5 +58,5 @@ namespace armarx::aron::typenavigator
{
return "AronIVTCByteImageType";
}
-}
+}*/
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.h
similarity index 81%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.h
index 83927a86d1baf61b98d443086539fb32f638d2fe..0003ee5f52b0eeddc4c9f352a222e5665916f413 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/IVTCByteImage.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/IVTCByteImage.h
@@ -24,33 +24,33 @@
#pragma once
// STD/STL
-#include <string>
+/*#include <string>
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
class IVTCByteImageNavigator;
typedef std::shared_ptr<IVTCByteImageNavigator> IVTCByteImageNavigatorPtr;
class IVTCByteImageNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronIVTCByteImage, IVTCByteImageNavigator>
+ virtual public detail::NDArrayVariant<type::dto::AronIVTCByteImage, IVTCByteImageNavigator>
{
public:
// constructors
IVTCByteImageNavigator(const Path& path = Path());
- IVTCByteImageNavigator(const type::AronIVTCByteImagePtr&, const Path& path);
+ IVTCByteImageNavigator(const type::dto::AronIVTCByteImagePtr&, const Path& path);
// operators
virtual bool operator==(const IVTCByteImageNavigator&) const override;
// public member functions
- type::AronIVTCByteImagePtr toAronIVTCByteImagePtr() const;
+ type::dto::AronIVTCByteImagePtr toAronIVTCByteImagePtr() const;
// virtual implementations
- virtual std::string getName() const override;
+ virtual std::string getFullName() const override;
public:
const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
@@ -60,4 +60,4 @@ namespace armarx::aron::typenavigator
{"RGB24Split", {"CByteImage::ImageType::eRGB24Split", "ImageType::eRGB24Split"}}
};
};
-}
+}*/
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4efd4c8ca3a0e414460d4506f7db75f18865b01
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.cpp
@@ -0,0 +1,82 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Image.h"
+
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+#include <SimoxUtility/algorithm/string.h>
+#include <SimoxUtility/meta/EnumNames.hpp>
+
+
+namespace armarx::aron::type
+{
+ const std::map<image::PixelType, std::string> Image::Pixeltype2String
+ {
+ {image::PixelType::rgb24, "rgb24"},
+ {image::PixelType::depth32, "depth32"}
+ };
+ const std::map<std::string, image::PixelType> Image::String2Pixeltype = conversion::util::InvertMap(Pixeltype2String);
+
+
+ // constructors
+ Image::Image(const Path& path) :
+ detail::NDArrayVariant<type::dto::Image, Image>(type::Descriptor::eImage, path)
+ {
+ }
+
+
+ Image::Image(const type::dto::Image& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Image, Image>(o, type::Descriptor::eImage, path)
+ {
+ }
+
+ type::dto::ImagePtr Image::toImageDTO() const
+ {
+ return this->aron;
+ }
+
+
+ image::PixelType Image::getPixelType() const
+ {
+ return aron->pixelType;
+ }
+
+ void Image::setPixelType(const image::PixelType pixelType) const
+ {
+ aron->pixelType = pixelType;
+ }
+
+ // virtual implementations
+ std::string Image::getShortName() const
+ {
+ return "Image";
+ }
+
+ std::string Image::getFullName() const
+ {
+ return "armarx::aron::type::Image<" + Pixeltype2String.at(this->aron->pixelType) + ">";
+ }
+
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b9f9dd0992c79187368a7136b7fa957a42cacae
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h
@@ -0,0 +1,60 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Rainer Kartmann (rainer dot kartmann at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD / STL
+#include <memory>
+#include <string>
+
+// Base Class
+#include "../detail/NDArrayVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The Image class. It represents the image type.
+ * The code generation manages, which code will be generated for this type object, e.g. c++ generates opencv code.
+ */
+ class Image :
+ public detail::NDArrayVariant<type::dto::Image, Image>
+ {
+ public:
+ // constructors
+ Image(const Path& path = {});
+ Image(const type::dto::Image&, const Path& path);
+
+ type::dto::ImagePtr toImageDTO() const;
+
+ /// Get the pixel type.
+ image::PixelType getPixelType() const;
+ void setPixelType(const image::PixelType type) const;
+
+ // virtual implementations
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+
+ static const std::map<image::PixelType, std::string> Pixeltype2String;
+ static const std::map<std::string, image::PixelType> String2Pixeltype;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62eabd986890eb92cd5bf9b050c887ff985da6d6
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.cpp
@@ -0,0 +1,108 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Matrix.h"
+
+// Simox
+#include <SimoxUtility/algorithm/vector.hpp>
+
+namespace armarx::aron::type
+{
+ const std::map<matrix::ElementType, std::string> Matrix::Elementtype2String
+ {
+ {matrix::ElementType::int16, "int16"},
+ {matrix::ElementType::int32, "int32"},
+ {matrix::ElementType::int64, "int64"},
+ {matrix::ElementType::float32, "float32"},
+ {matrix::ElementType::float64, "float64"}
+ };
+
+ const std::map<std::string, matrix::ElementType> Matrix::String2Elementtype = conversion::util::InvertMap(Elementtype2String);
+
+ // constructors
+ Matrix::Matrix(const Path& path) :
+ detail::NDArrayVariant<type::dto::Matrix, Matrix>(type::Descriptor::eMatrix, path)
+ {
+ }
+
+ Matrix::Matrix(const type::dto::Matrix& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Matrix, Matrix>(o, type::Descriptor::eMatrix, path)
+ {
+ }
+
+ unsigned int Matrix::getRows() const
+ {
+ return this->aron->rows;
+ }
+
+ unsigned int Matrix::getCols() const
+ {
+ return this->aron->cols;
+ }
+
+ void Matrix::setRows(const int w)
+ {
+ if (w == 0 || w < -1)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The rows cannot be 0 or < -1", getPath());
+ }
+ this->aron->rows = w;
+ }
+
+ void Matrix::setCols(const int h)
+ {
+ if (h == 0 || h < -1)
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "The cols cannot be 0 or < -1", getPath());
+ }
+ this->aron->cols = h;
+ }
+
+ type::matrix::ElementType Matrix::getElementType() const
+ {
+ return this->aron->elementType;
+ }
+
+ void Matrix::setElementType(const type::matrix::ElementType u)
+ {
+ this->aron->elementType = u;;
+ }
+
+ type::dto::MatrixPtr Matrix::toMatrixDTO() const
+ {
+ return this->aron;
+ }
+
+ // virtual implementations
+ std::string Matrix::getShortName() const
+ {
+ return "Matrix";
+ }
+
+ std::string Matrix::getFullName() const
+ {
+ return "armarx::aron::type::Matrix<" + std::to_string(this->aron->rows) + ", " + std::to_string(this->aron->cols) + ", " + Elementtype2String.at(this->aron->elementType) + ">";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h
similarity index 52%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h
index b4deca5fe53786f98e8502ce9401985ee2f02eb6..da9fd537dbcf62f9e17e54b9c42815009d408e8a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/NDArray.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h
@@ -28,37 +28,37 @@
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class NDArrayNavigator;
- typedef std::shared_ptr<NDArrayNavigator> NDArrayNavigatorPtr;
-
- class NDArrayNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronNDArray, NDArrayNavigator>
+ /**
+ * @brief The Matrix class. It represents the matrix type
+ * A Matrix is defined through the number of rows, cols and the element type
+ */
+ class Matrix :
+ public detail::NDArrayVariant<type::dto::Matrix, Matrix>
{
public:
// constructors
- NDArrayNavigator(const Path& path = Path());
- NDArrayNavigator(const type::AronNDArrayPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const NDArrayNavigator&) const override;
+ Matrix(const Path& path = Path());
+ Matrix(const type::dto::Matrix&, const Path& path = Path());
- // public member functions
- std::string getTypename() const;
- std::vector<int> getDimensions() const;
- unsigned int getElementSize() const;
+ unsigned int getRows() const;
+ unsigned int getCols() const;
+ type::matrix::ElementType getElementType() const;
- void setTypename(const std::string&);
- void setDimensions(const std::vector<int>&);
- void addDimension(int);
- void setElementSize(unsigned int);
+ void setRows(const int);
+ void setCols(const int);
+ void setElementType(const type::matrix::ElementType);
- type::AronNDArrayPtr toAronNDArrayPtr() const;
+ type::dto::MatrixPtr toMatrixDTO() const;
// virtual implementations
- virtual std::string getName() const override;
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+
+ static const std::map<matrix::ElementType, std::string> Elementtype2String;
+ static const std::map<std::string, matrix::ElementType> String2Elementtype;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.cpp
index 79cbe06d5560b27acd3a8e790b9bcbff9565b9cd..cbbf517ba53d9e3d50342298b1c34b2652662216 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.cpp
@@ -22,41 +22,60 @@
*/
// Header
-#include "Orientation.h"
+#include "NDArray.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
// constructors
- OrientationNavigator::OrientationNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path)
+ NDArray::NDArray(const Path& path) :
+ detail::NDArrayVariant<type::dto::NDArray, NDArray>(type::Descriptor::eNDArray, path)
{
}
- OrientationNavigator::OrientationNavigator(const type::AronOrientationPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path),
- detail::NavigatorBase<type::AronOrientation, OrientationNavigator>(o)
+ NDArray::NDArray(const type::dto::NDArray& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::NDArray, NDArray>(o, type::Descriptor::eNDArray, path)
{
}
- // operators
- bool OrientationNavigator::operator==(const OrientationNavigator& other) const
+ type::dto::NDArrayPtr NDArray::toNDArrayDTO() const
{
- if (getMaybe() != other.getMaybe())
- {
- return false;
- }
- return true;
+ return this->aron;
}
- type::AronOrientationPtr OrientationNavigator::toAronOrientationPtr() const
+ int NDArray::getNumberDimensions() const
{
- return this->aron;
+ return this->aron->ndimensions;
+ }
+
+ type::ndarray::ElementType NDArray::getElementType() const
+ {
+ return this->aron->elementType;
+ }
+
+ void NDArray::setElementType(type::ndarray::ElementType s)
+ {
+ this->aron->elementType = s;
+ }
+
+ void NDArray::setNumberDimensions(int v)
+ {
+ this->aron->ndimensions = v;
+ }
+
+ void NDArray::addDimension()
+ {
+ this->aron->ndimensions++;
}
// virtual implementations
- std::string OrientationNavigator::getName() const
+ std::string NDArray::getShortName() const
+ {
+ return "NDArray";
+ }
+
+ std::string NDArray::getFullName() const
{
- return "AronOrientationType";
+ return "armarx::aron::type::NDArray";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h
index 19bb1834b6e597631539d0da8027eef56f2fa8be..d04d218eb5ce19a1d53b8d1851b00d3a9ba7925a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h
@@ -28,32 +28,33 @@
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class PositionNavigator;
- typedef std::shared_ptr<PositionNavigator> PositionNavigatorPtr;
-
- class PositionNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronPosition, PositionNavigator>
+ /**
+ * @brief The NDArray class. It represents an arbitrary array type
+ */
+ class NDArray :
+ public detail::NDArrayVariant<type::dto::NDArray, NDArray>
{
public:
// constructors
- PositionNavigator(const Path& path = Path());
- PositionNavigator(const type::AronPositionPtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const PositionNavigator&) const override;
+ NDArray(const Path& path = Path());
+ NDArray(const type::dto::NDArray&, const Path& path = Path());
// public member functions
- type::AronPositionPtr toAronPositionPtr() const;
+ type::ndarray::ElementType getElementType() const;
+ int getNumberDimensions() const;
- // virtual implementations
- std::string getName() const override;
+ void setElementType(type::ndarray::ElementType);
+ void setNumberDimensions(int);
+ void addDimension();
- public:
- const std::string ACCEPTED_TYPE = "float";
- const std::vector<int> ACCEPTED_DIMENSION = {3, 1};
+ type::dto::NDArrayPtr toNDArrayDTO() const;
+
+ // virtual implementations
+ std::string getShortName() const override;
+ std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.cpp
similarity index 79%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.cpp
index bf805025d848c2d405c359d595edd7d4e7a94adc..43ff6597293a6ce950b80905933bb28beafc6d47 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.cpp
@@ -21,7 +21,7 @@
* GNU General Public License
*/
-// Header
+/*// Header
#include "OpenCVMat.h"
namespace armarx::aron::typenavigator
@@ -29,14 +29,14 @@ namespace armarx::aron::typenavigator
// constructors
OpenCVMatNavigator::OpenCVMatNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOpenCVMat, path)
+ aron::Navigator<type::Descriptor, type::dto::GenericType>::Navigator(type::Descriptor::eOpenCVMat, path)
{
}
- OpenCVMatNavigator::OpenCVMatNavigator(const type::AronOpenCVMatPtr& o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOpenCVMat, path),
- detail::NavigatorBase<type::AronOpenCVMat, OpenCVMatNavigator>(o)
+ OpenCVMatNavigator::OpenCVMatNavigator(const type::dto::AronOpenCVMatPtr& o, const Path& path) :
+ aron::Navigator<type::Descriptor, type::dto::GenericType>::Navigator(type::Descriptor::eOpenCVMat, path),
+ detail::NavigatorBase<type::dto::AronOpenCVMat, OpenCVMatNavigator>(o)
{
}
@@ -52,7 +52,7 @@ namespace armarx::aron::typenavigator
}
- type::AronOpenCVMatPtr OpenCVMatNavigator::toAronOpenCVMatPtr() const
+ type::dto::AronOpenCVMatPtr OpenCVMatNavigator::toAronOpenCVMatPtr() const
{
return this->aron;
}
@@ -88,5 +88,5 @@ namespace armarx::aron::typenavigator
return "AronOpenCVMatType";
}
-}
+}*/
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.h
similarity index 87%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.h
index 46c62277da75e4c785137aa948b5388fefb8035e..d48a1b983722455b2066f9d23c35f9eeca4178f7 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/OpenCVMat.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/OpenCVMat.h
@@ -23,12 +23,12 @@
#pragma once
-// STD/STL
+/*// STD/STL
#include <string>
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
namespace armarx::aron::typenavigator
@@ -37,18 +37,18 @@ namespace armarx::aron::typenavigator
typedef std::shared_ptr<OpenCVMatNavigator> OpenCVMatNavigatorPtr;
class OpenCVMatNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronOpenCVMat, OpenCVMatNavigator>
+ virtual public detail::NDArrayNavigatorBase<type::dto::AronOpenCVMat, OpenCVMatNavigator>
{
public:
// constructors
OpenCVMatNavigator(const Path& path = Path());
- OpenCVMatNavigator(const type::AronOpenCVMatPtr&, const Path& path);
+ OpenCVMatNavigator(const type::dto::AronOpenCVMatPtr&, const Path& path);
// operators
virtual bool operator==(const OpenCVMatNavigator&) const override;
// public member functions
- type::AronOpenCVMatPtr toAronOpenCVMatPtr() const;
+ type::dto::AronOpenCVMatPtr toAronOpenCVMatPtr() const;
std::vector<int> getShape() const;
void setShape(const std::vector<int>& shape) const;
@@ -72,4 +72,4 @@ namespace armarx::aron::typenavigator
{"CV_64F", {"64F"}}
};
};
-}
+}*/
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..031fd6f73e7d2f924d8723107325cb16c3b57d46
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.cpp
@@ -0,0 +1,56 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Orientation.h"
+
+namespace armarx::aron::type
+{
+ // constructors
+ Orientation::Orientation(const Path& path) :
+ detail::NDArrayVariant<type::dto::Orientation, Orientation>(type::Descriptor::eOrientation, path)
+ {
+ }
+
+ Orientation::Orientation(const type::dto::Orientation& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Orientation, Orientation>(o, type::Descriptor::eOrientation, path)
+ {
+ }
+
+ type::dto::OrientationPtr Orientation::toOrientationDTO() const
+ {
+ return this->aron;
+ }
+
+ // virtual implementations
+ std::string Orientation::getShortName() const
+ {
+ return "Orientation";
+ }
+
+ std::string Orientation::getFullName() const
+ {
+ return "armarx::aron::type::Orientation";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.h
similarity index 58%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.h
index 6b2df5228b77f93395fd2c653718c2c64637266a..b4bebb8ca5e40d782681e88bed6f9bad30afd128 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Orientation.h
@@ -28,32 +28,27 @@
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class OrientationNavigator;
- typedef std::shared_ptr<OrientationNavigator> OrientationNavigatorPtr;
-
- class OrientationNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronOrientation, OrientationNavigator>
+ /**
+ * @brief The Orientation class. It represents the orientation type. The generated code will most probably be related to the Quaternion type
+ * It does not have any parameters since it is assumed to be similar to Quaternion with float type
+ */
+ class Orientation :
+ public detail::NDArrayVariant<type::dto::Orientation, Orientation>
{
public:
// constructors
- OrientationNavigator(const Path& path = Path());
- OrientationNavigator(const type::AronOrientationPtr&, const Path& path);
-
- // operators
- virtual bool operator==(const OrientationNavigator&) const override;
+ Orientation(const Path& path = Path());
+ Orientation(const type::dto::Orientation&, const Path& path);
// public member functions
- type::AronOrientationPtr toAronOrientationPtr() const;
+ type::dto::OrientationPtr toOrientationDTO() const;
// virtual implementations
- virtual std::string getName() const override;
-
- public:
- const std::string ACCEPTED_TYPE = "float";
- const std::vector<int> ACCEPTED_DIMENSION = {1, 4};
+ std::string getShortName() const override;
+ std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10a3473021b616c78cc7e88b2e45dc94226663bb
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.cpp
@@ -0,0 +1,79 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "PointCloud.h"
+
+namespace armarx::aron::type
+{
+ const std::map<pointcloud::VoxelType, std::string> PointCloud::Voxeltype2String
+ {
+ {pointcloud::VoxelType::PointXYZ, "PointXYZ"},
+ {pointcloud::VoxelType::PointXYZI, "PointXYZI"},
+ {pointcloud::VoxelType::PointXYZL, "PointXYZL"},
+ {pointcloud::VoxelType::PointXYZRGB, "PointXYZRGB"},
+ {pointcloud::VoxelType::PointXYZRGBL, "PointXYZRGBL"},
+ {pointcloud::VoxelType::PointXYZRGBA, "PointXYZRGBA"},
+ {pointcloud::VoxelType::PointXYZHSV, "PointXYZHSV"}
+ };
+
+ const std::map<std::string, pointcloud::VoxelType> PointCloud::String2Voxeltype = conversion::util::InvertMap(Voxeltype2String);
+
+ // constructors
+ PointCloud::PointCloud(const Path& path) :
+ detail::NDArrayVariant<type::dto::PointCloud, PointCloud>(type::Descriptor::ePointCloud, path)
+ {
+ }
+
+ PointCloud::PointCloud(const type::dto::PointCloud& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::PointCloud, PointCloud>(o, type::Descriptor::ePointCloud, path)
+ {
+ }
+
+ type::dto::PointCloudPtr PointCloud::toPointCloudDTO() const
+ {
+ return this->aron;
+ }
+
+ type::pointcloud::VoxelType PointCloud::getVoxelType() const
+ {
+ return this->aron->voxelType;
+ }
+
+ void PointCloud::setVoxelType(type::pointcloud::VoxelType u)
+ {
+ this->aron->voxelType = u;
+ }
+
+ // virtual implementations
+ std::string PointCloud::getShortName() const
+ {
+ return "PointCloud";
+ }
+
+ std::string PointCloud::getFullName() const
+ {
+ return "armarx::aron::type::PointCloud<" + Voxeltype2String.at(this->aron->voxelType) + ">";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h
new file mode 100644
index 0000000000000000000000000000000000000000..37d3aacdbed11c396cdc7351f8e7077705f2e2a6
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h
@@ -0,0 +1,61 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+#include <map>
+
+// Base class
+#include "../detail/NDArrayVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The PointCloud class. It represents the pointcloud type.
+ * A pointcloud is defined through a type. The dimension is NOT part of the type description
+ */
+ class PointCloud :
+ public detail::NDArrayVariant<type::dto::PointCloud, PointCloud>
+ {
+ public:
+ // constructors
+ PointCloud(const Path& path = Path());
+ PointCloud(const type::dto::PointCloud&, const Path& path);
+
+ // public member functions
+ type::pointcloud::VoxelType getVoxelType() const;
+
+ void setVoxelType(type::pointcloud::VoxelType);
+
+ type::dto::PointCloudPtr toPointCloudDTO() const;
+
+ // virtual implementations
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+
+ static const std::map<pointcloud::VoxelType, std::string> Voxeltype2String;
+ static const std::map<std::string, pointcloud::VoxelType> String2Voxeltype;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6965c12ba714ef01242c4e1420a9579ec11aa4e
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.cpp
@@ -0,0 +1,56 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Pose.h"
+
+namespace armarx::aron::type
+{
+ // constructors
+ Pose::Pose(const Path& path) :
+ detail::NDArrayVariant<type::dto::Pose, Pose>(type::Descriptor::ePose, path)
+ {
+ }
+
+ Pose::Pose(const type::dto::Pose& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Pose, Pose>(o, type::Descriptor::ePose, path)
+ {
+ }
+
+ type::dto::PosePtr Pose::toPoseDTO() const
+ {
+ return this->aron;
+ }
+
+ // virtual implementations
+ std::string Pose::getShortName() const
+ {
+ return "Pose";
+ }
+
+ std::string Pose::getFullName() const
+ {
+ return "armarx::aron::type::Pose";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.h
similarity index 61%
rename from source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h
rename to source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.h
index 6277f027273049e98d6e1c8b18ac29c36ed5e23b..fa2c1f184799004ab64f875cfe3cb749d743b6c9 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Pose.h
@@ -28,32 +28,27 @@
#include <map>
// Base class
-#include "../detail/NDArrayNavigatorBase.h"
+#include "../detail/NDArrayVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class PoseNavigator;
- typedef std::shared_ptr<PoseNavigator> PoseNavigatorPtr;
-
- class PoseNavigator :
- virtual public detail::NDArrayNavigatorBase<type::AronPose, PoseNavigator>
+ /**
+ * @brief The Pose class. It represents the pose type
+ * It does not have any parameters since it is assumed to be similar to a 4x4 Matrix with float type
+ */
+ class Pose :
+ public detail::NDArrayVariant<type::dto::Pose, Pose>
{
public:
// constructors
- PoseNavigator(const Path& path = Path());
- PoseNavigator(const type::AronPosePtr&, const Path& path = Path());
-
- // operators
- virtual bool operator==(const PoseNavigator&) const override;
+ Pose(const Path& path = Path());
+ Pose(const type::dto::Pose&, const Path& path = Path());
// public member functions
- type::AronPosePtr toAronPosePtr() const;
+ type::dto::PosePtr toPoseDTO() const;
// virtual implementations
- virtual std::string getName() const override;
-
- public:
- const std::string ACCEPTED_TYPE = "float";
- const std::vector<int> ACCEPTED_DIMENSION = {4, 4};
+ std::string getShortName() const override;
+ std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..68effb684d71d5745e02df03e4a396ac00cc2551
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.cpp
@@ -0,0 +1,56 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Position.h"
+
+namespace armarx::aron::type
+{
+ // constructors
+ Position::Position(const Path& path) :
+ detail::NDArrayVariant<type::dto::Position, Position>(type::Descriptor::ePosition, path)
+ {
+ }
+
+ Position::Position(const type::dto::Position& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Position, Position>(o, type::Descriptor::ePosition, path)
+ {
+ }
+
+ type::dto::PositionPtr Position::toPositionDTO() const
+ {
+ return this->aron;
+ }
+
+ // virtual implementations
+ std::string Position::getShortName() const
+ {
+ return "Position";
+ }
+
+ std::string Position::getFullName() const
+ {
+ return "armarx::aron::type::Position";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.h
new file mode 100644
index 0000000000000000000000000000000000000000..427f0f43a6f5c32dd7b7d16950cbc301de3f309a
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Position.h
@@ -0,0 +1,54 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+#include <map>
+
+// Base class
+#include "../detail/NDArrayVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The Position class. It represents the position type
+ * It does not have any parameters since it is assumed to be a 3x1 Matrix with float type
+ */
+ class Position :
+ public detail::NDArrayVariant<type::dto::Position, Position>
+ {
+ public:
+ // constructors
+ Position(const Path& path = Path());
+ Position(const type::dto::Position&, const Path& path = Path());
+
+ // public member functions
+ type::dto::PositionPtr toPositionDTO() const;
+
+ // virtual implementations
+ std::string getShortName() const override;
+ std::string getFullName() const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.cpp b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5457ee84421cc570dda07881070f6f9249359b73
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.cpp
@@ -0,0 +1,75 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "Quaternion.h"
+
+#include <SimoxUtility/algorithm/string/string_conversion.h>
+
+namespace armarx::aron::type
+{
+ const std::map<quaternion::ElementType, std::string> Quaternion::Elementtype2String =
+ {
+ {quaternion::ElementType::float32, "float32"},
+ {quaternion::ElementType::float64, "float64"}
+ };
+ const std::map<std::string, quaternion::ElementType> Quaternion::String2Elementtype = conversion::util::InvertMap(Elementtype2String);
+
+ // constructors
+ Quaternion::Quaternion(const Path& path) :
+ detail::NDArrayVariant<type::dto::Quaternion, Quaternion>(type::Descriptor::eQuaternion, path)
+ {
+ }
+
+ Quaternion::Quaternion(const type::dto::Quaternion& o, const Path& path) :
+ detail::NDArrayVariant<type::dto::Quaternion, Quaternion>(o, type::Descriptor::eQuaternion, path)
+ {
+ }
+
+ type::dto::QuaternionPtr Quaternion::toQuaternionDTO() const
+ {
+ return this->aron;
+ }
+
+ type::quaternion::ElementType Quaternion::getElementType() const
+ {
+ return this->aron->elementType;
+ }
+
+ void Quaternion::setElementType(type::quaternion::ElementType t)
+ {
+ this->aron->elementType = t;
+ }
+
+ // virtual implementations
+ std::string Quaternion::getShortName() const
+ {
+ return "Quaternion";
+ }
+
+ std::string Quaternion::getFullName() const
+ {
+ return "armarx::aron::type::Quaternion<" + Elementtype2String.at(this->aron->elementType) + ">";
+ }
+}
+
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h
new file mode 100644
index 0000000000000000000000000000000000000000..f660702be8c84613877d164763914bcf4cd57bc9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h
@@ -0,0 +1,60 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+#include <map>
+
+// Base class
+#include "../detail/NDArrayVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The Qaternion class. It represents the quaternion type
+ * A Quaternion has dimension 1x4 and a varying type
+ */
+ class Quaternion :
+ public detail::NDArrayVariant<type::dto::Quaternion, Quaternion>
+ {
+ public:
+ // constructors
+ Quaternion(const Path& path = Path());
+ Quaternion(const type::dto::Quaternion&, const Path& path);
+
+ // public member functions
+ type::quaternion::ElementType getElementType() const;
+ void setElementType(type::quaternion::ElementType);
+
+ type::dto::QuaternionPtr toQuaternionDTO() const;
+
+ // virtual implementations
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+
+ static const std::map<quaternion::ElementType, std::string> Elementtype2String;
+ static const std::map<std::string, quaternion::ElementType> String2Elementtype;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/primitive/All.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/All.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee4877b10d9b3294a681042961788a99d2d5077c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/All.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Int.h"
+#include "Long.h"
+#include "Float.h"
+#include "Double.h"
+#include "String.h"
+#include "Bool.h"
+#include "Time.h"
+
+/**
+ * A convenience header to include all primitive aron files (full include, not forward declared)
+ */
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.cpp
similarity index 66%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.cpp
index ae187d241f1f19c79673a593b12fe9da8eea7918..9eca559042cb6d38e575399b604e51f194f8aec7 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.cpp
@@ -29,28 +29,32 @@
// Header
#include "Bool.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- BoolNavigator::BoolNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eBool, path)
+ Bool::Bool(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronBool, Bool>(type::Descriptor::eBool, path)
{
}
- BoolNavigator::BoolNavigator(const type::AronBoolPtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eBool, path),
- detail::NavigatorBase<type::AronBool, BoolNavigator>(o)
+ Bool::Bool(const type::dto::AronBool&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronBool, Bool>(o, type::Descriptor::eBool, path)
{
}
- type::AronBoolPtr BoolNavigator::toAronBoolPtr() const
+ type::dto::AronBoolPtr Bool::toBoolDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string BoolNavigator::getName() const
+ std::string Bool::getShortName() const
{
- return "type::AronBool";
+ return "Bool";
+ }
+
+ std::string Bool::getFullName() const
+ {
+ return "armarx::aron::type::Bool";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.h
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.h
index d8cc1f53b1f1261ba46983b6d506df3d90111e63..eac4aeaea068387ba065a98376a64212a2fc2307 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Bool.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Bool.h
@@ -27,24 +27,25 @@
#include <string>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class BoolNavigator;
- typedef std::shared_ptr<BoolNavigator> BoolNavigatorPtr;
-
- class BoolNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronBool, BoolNavigator>
+ /**
+ * @brief The Bool class. It represents the bool type
+ */
+ class Bool :
+ public detail::PrimitiveVariant<type::dto::AronBool, Bool>
{
public:
/* constructors */
- BoolNavigator(const Path& = Path());
- BoolNavigator(const type::AronBoolPtr&, const Path& = Path());
+ Bool(const Path& = Path());
+ Bool(const type::dto::AronBool&, const Path& = Path());
- type::AronBoolPtr toAronBoolPtr() const;
+ type::dto::AronBoolPtr toBoolDTO() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.cpp
similarity index 65%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.cpp
index 98fff8740e8c2afdd9781d7eb5fc89c0469cd82e..256e0a61fa70bb46f1580553de206f16ef2fbddd 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.cpp
@@ -29,28 +29,32 @@
// Header
#include "Double.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- DoubleNavigator::DoubleNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eDouble, path)
+ Double::Double(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronDouble, Double>(type::Descriptor::eDouble, path)
{
}
- DoubleNavigator::DoubleNavigator(const type::AronDoublePtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eDouble, path),
- detail::NavigatorBase<type::AronDouble, DoubleNavigator>(o)
+ Double::Double(const type::dto::AronDouble&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronDouble, Double>(o, type::Descriptor::eDouble, path)
{
}
- type::AronDoublePtr DoubleNavigator::toAronDoublePtr() const
+ type::dto::AronDoublePtr Double::toDoubleDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string DoubleNavigator::getName() const
+ std::string Double::getShortName() const
{
- return "type::AronDouble";
+ return "Double";
+ }
+
+ std::string Double::getFullName() const
+ {
+ return "armarx::aron::type::Double";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.h
similarity index 67%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.h
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.h
index 6f583207a03cb0806c5ca7f15d84c051a047bc36..17aa98ad764ac8081cfcd2e23aad38f388749d18 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Double.h
@@ -27,24 +27,25 @@
#include <string>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class FloatNavigator;
- typedef std::shared_ptr<FloatNavigator> FloatNavigatorPtr;
-
- class FloatNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronFloat, FloatNavigator>
+ /**
+ * @brief The Double class. It represents the double type
+ */
+ class Double :
+ public detail::PrimitiveVariant<type::dto::AronDouble, Double>
{
public:
/* constructors */
- FloatNavigator(const Path& = Path());
- FloatNavigator(const type::AronFloatPtr&, const Path& = Path());
+ Double(const Path& = Path());
+ Double(const type::dto::AronDouble&, const Path& = Path());
- type::AronFloatPtr toAronFloatPtr() const;
+ type::dto::AronDoublePtr toDoubleDTO() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.cpp
similarity index 66%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.cpp
index 277ea6bf525bf8e4eb7da12d0ecf2da44e6e9618..3d08b5bdaae4aa689761bb181aee1d688e0dd8a2 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Float.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.cpp
@@ -29,28 +29,32 @@
// Header
#include "Float.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- FloatNavigator::FloatNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eFloat, path)
+ Float::Float(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronFloat, Float>(type::Descriptor::eFloat, path)
{
}
- FloatNavigator::FloatNavigator(const type::AronFloatPtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eFloat, path),
- detail::NavigatorBase<type::AronFloat, FloatNavigator>(o)
+ Float::Float(const type::dto::AronFloat&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronFloat, Float>(o, type::Descriptor::eFloat, path)
{
}
- type::AronFloatPtr FloatNavigator::toAronFloatPtr() const
+ type::dto::AronFloatPtr Float::toFloatDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string FloatNavigator::getName() const
+ std::string Float::getShortName() const
{
- return "type::AronFloat";
+ return "Float";
+ }
+
+ std::string Float::getFullName() const
+ {
+ return "armarx::aron::type::Float";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.h
new file mode 100644
index 0000000000000000000000000000000000000000..2dedfb1739b6f000baddc8bb13306781a3d34a99
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Float.h
@@ -0,0 +1,51 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+
+// Base class
+#include "../detail/PrimitiveVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The Float class. It represents the float type
+ */
+ class Float :
+ public detail::PrimitiveVariant<type::dto::AronFloat, Float>
+ {
+ public:
+ /* constructors */
+ Float(const Path& = Path());
+ Float(const type::dto::AronFloat&, const Path& = Path());
+
+ type::dto::AronFloatPtr toFloatDTO() const;
+
+ /* virtual implementations */
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.cpp
similarity index 67%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.cpp
index 89a78c5616a6d70f278ab9da56bf5df8f0b3d27f..b371f53ddf1f82275d334e0752367e01fec57c93 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.cpp
@@ -29,28 +29,32 @@
// Header
#include "Int.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- IntNavigator::IntNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eInt, path)
+ Int::Int(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronInt, Int>(type::Descriptor::eInt, path)
{
}
- IntNavigator::IntNavigator(const type::AronIntPtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eInt, path),
- detail::NavigatorBase<type::AronInt, IntNavigator>(o)
+ Int::Int(const type::dto::AronInt&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronInt, Int>(o, type::Descriptor::eInt, path)
{
}
- type::AronIntPtr IntNavigator::toAronIntPtr() const
+ type::dto::AronIntPtr Int::toIntDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string IntNavigator::getName() const
+ std::string Int::getShortName() const
{
- return "type::AronInt";
+ return "Int";
+ }
+
+ std::string Int::getFullName() const
+ {
+ return "armarx::aron::type::Int";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.h
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.h
index 552b51e1778e1114f187a283229f3fe738577fbc..240cd4a50df8687f8cdba2ff15c040d21ec27fbe 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Int.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Int.h
@@ -27,24 +27,25 @@
#include <string>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class IntNavigator;
- typedef std::shared_ptr<IntNavigator> IntNavigatorPtr;
-
- class IntNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronInt, IntNavigator>
+ /**
+ * @brief The Int class. It represents the int type
+ */
+ class Int :
+ public detail::PrimitiveVariant<type::dto::AronInt, Int>
{
public:
/* constructors */
- IntNavigator(const Path& = Path());
- IntNavigator(const type::AronIntPtr&, const Path& = Path());
+ Int(const Path& = Path());
+ Int(const type::dto::AronInt&, const Path& = Path());
- type::AronIntPtr toAronIntPtr() const;
+ type::dto::AronIntPtr toIntDTO() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.cpp
similarity index 66%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.cpp
index 0f00f590a83b77a070f90597be596298c826dacc..2654a773d6f00f2552e7246007294baa161de1bf 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.cpp
@@ -29,28 +29,32 @@
// Header
#include "Long.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- LongNavigator::LongNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eLong, path)
+ Long::Long(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronLong, Long>(type::Descriptor::eLong, path)
{
}
- LongNavigator::LongNavigator(const type::AronLongPtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eLong, path),
- detail::NavigatorBase<type::AronLong, LongNavigator>(o)
+ Long::Long(const type::dto::AronLong&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronLong, Long>(o, type::Descriptor::eLong, path)
{
}
- type::AronLongPtr LongNavigator::toAronLongPtr() const
+ type::dto::AronLongPtr Long::toLongDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string LongNavigator::getName() const
+ std::string Long::getShortName() const
{
- return "type::AronLong";
+ return "Long";
+ }
+
+ std::string Long::getFullName() const
+ {
+ return "armarx::aron::type::Long";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.h
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.h
index fb7b455587cee532d78c145990d50e5d3304dddf..710df1a421e5ff684ac85b70839ff7cff513378e 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Long.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Long.h
@@ -27,24 +27,25 @@
#include <string>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class LongNavigator;
- typedef std::shared_ptr<LongNavigator> LongNavigatorPtr;
-
- class LongNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronLong, LongNavigator>
+ /**
+ * @brief The Long class. It represents the long type
+ */
+ class Long :
+ public detail::PrimitiveVariant<type::dto::AronLong, Long>
{
public:
/* constructors */
- LongNavigator(const Path& = Path());
- LongNavigator(const type::AronLongPtr&, const Path& = Path());
+ Long(const Path& = Path());
+ Long(const type::dto::AronLong&, const Path& = Path());
- type::AronLongPtr toAronLongPtr() const;
+ type::dto::AronLongPtr toLongDTO() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/String.cpp
similarity index 64%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/String.cpp
index 1ad8135634298ca3de84ae41743d36a58018461d..1cced6991fa157d23638241f1e012c2c0e7a4589 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/String.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/String.cpp
@@ -29,29 +29,33 @@
// Header
#include "String.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- StringNavigator::StringNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eString, path)
+ String::String(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronString, String>(type::Descriptor::eString, path)
{
}
- StringNavigator::StringNavigator(const type::AronStringPtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eString, path),
- detail::NavigatorBase<type::AronString, StringNavigator>(o)
+ String::String(const type::dto::AronString&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronString, String>(o, type::Descriptor::eString, path)
{
}
/* public member functions */
- type::AronStringPtr StringNavigator::toAronStringPtr() const
+ type::dto::AronStringPtr String::toStringDTO() const
{
- return this->aron;
+ return aron;
}
/* virtual implementations */
- std::string StringNavigator::getName() const
+ std::string String::getShortName() const
{
- return "type::AronString";
+ return "String";
+ }
+
+ std::string String::getFullName() const
+ {
+ return "armarx::aron::type::String";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/primitive/String.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/String.h
new file mode 100644
index 0000000000000000000000000000000000000000..54dedab7b228d2262097d0cbe59675c4f721eb39
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/String.h
@@ -0,0 +1,51 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <string>
+
+// Base class
+#include "../detail/PrimitiveVariant.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The String class. It represents the string type
+ */
+ class String :
+ public detail::PrimitiveVariant<type::dto::AronString, String>
+ {
+ public:
+ /* constructors */
+ String(const Path& = Path());
+ String(const type::dto::AronString&, const Path& = Path());
+
+ type::dto::AronStringPtr toStringDTO() const;
+
+ /* virtual implementations */
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.cpp b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.cpp
similarity index 67%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.cpp
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.cpp
index 09c04bebdc871d2b10ed47840e406b010b525317..76ba1e55c0c2d7d65c12760e6c66ef725ffbbd5c 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.cpp
@@ -29,29 +29,33 @@
// Header
#include "Time.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
/* constructors */
- TimeNavigator::TimeNavigator(const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTime, path)
+ Time::Time(const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronTime, Time>(type::Descriptor::eTime, path)
{
}
- TimeNavigator::TimeNavigator(const type::AronTimePtr&o, const Path& path) :
- aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTime, path),
- detail::NavigatorBase<type::AronTime, TimeNavigator>(o)
+ Time::Time(const type::dto::AronTime&o, const Path& path) :
+ detail::PrimitiveVariant<type::dto::AronTime, Time>(o, type::Descriptor::eTime, path)
{
}
/* public member functions */
- type::AronTimePtr TimeNavigator::toAronTimePtr() const
+ type::dto::AronTimePtr Time::toTimeDTO() const
{
return this->aron;
}
/* virtual implementations */
- std::string TimeNavigator::getName() const
+ std::string Time::getShortName() const
{
- return "type::AronTime";
+ return "Time";
+ }
+
+ std::string Time::getFullName() const
+ {
+ return "armarx::aron::type::Time";
}
}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.h b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.h
similarity index 68%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.h
rename to source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.h
index 7fd07408ee8db90c6591bf55c64804d511140ee5..bd92b965d9c280979732d1f8d54389153a13573f 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Time.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/primitive/Time.h
@@ -27,24 +27,25 @@
#include <string>
// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+#include "../detail/PrimitiveVariant.h"
-namespace armarx::aron::typenavigator
+namespace armarx::aron::type
{
- class TimeNavigator;
- typedef std::shared_ptr<TimeNavigator> TimeNavigatorPtr;
-
- class TimeNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronTime, TimeNavigator>
+ /**
+ * @brief The Time class. It represents the time type
+ */
+ class Time :
+ public detail::PrimitiveVariant<type::dto::AronTime, Time>
{
public:
/* constructors */
- TimeNavigator(const Path& = Path());
- TimeNavigator(const type::AronTimePtr&, const Path& = Path());
+ Time(const Path& = Path());
+ Time(const type::dto::AronTime&, const Path& = Path());
- type::AronTimePtr toAronTimePtr() const;
+ type::dto::AronTimePtr toTimeDTO() const;
/* virtual implementations */
- virtual std::string getName() const override;
+ virtual std::string getShortName() const override;
+ virtual std::string getFullName() const override;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91f88f210b4da29ebf905a7926f0edfcdedcb329
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "RecursiveVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..a49b0751edcc7d689fe8e57a1eca7d2d3fe4bcaf
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
@@ -0,0 +1,174 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <type_traits>
+
+#include "../../Descriptor.h"
+#include "Visitor.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The visitRecursive function. Calls visitX of a RecursiveVisitorImplementation recursively. For more information please see Visitor.h
+ */
+ template <class RecursiveVisitorImplementation>
+ void visitRecursive(RecursiveVisitorImplementation& v, typename RecursiveVisitorImplementation::Input& t)
+ {
+ auto descriptor = v.getDescriptor(t);
+ switch (descriptor)
+ {
+ case type::Descriptor::eList:
+ {
+ v.visitListOnEnter(t);
+ auto acceptedType = v.getListAcceptedType(t);
+ visitRecursive(v, acceptedType);
+ v.visitListOnExit(t);
+ return;
+ }
+ case type::Descriptor::ePair:
+ {
+ v.visitPairOnEnter(t);
+ auto acceptedTypes = v.getPairAcceptedTypes(t);
+ visitRecursive(v, acceptedTypes.first);
+ visitRecursive(v, acceptedTypes.second);
+ v.visitPairOnExit(t);
+ return;
+ }
+ case type::Descriptor::eTuple:
+ {
+ v.visitTupleOnEnter(t);
+ unsigned int i = 0;
+ for (const auto& acceptedType : v.getTupleAcceptedTypes(t))
+ {
+ visitRecursive(v, acceptedType);
+ i++;
+ }
+ v.visitTupleOnExit(t);
+ return;
+ }
+ case type::Descriptor::eDict:
+ {
+ v.visitDictOnEnter(t);
+ auto acceptedType = v.getDictAcceptedType(t);
+ visitRecursive(v, acceptedType);
+ v.visitDictOnExit(t);
+ return;
+ }
+ case type::Descriptor::eObject:
+ {
+ v.visitObjectOnEnter(t);
+ for (const auto& [key, acceptedType] : v.getObjectElements(t))
+ {
+ visitRecursive(v, acceptedType);
+ }
+ v.visitObjectOnExit(t);
+ return;
+ }
+ case type::Descriptor::eNDArray:
+ return v.visitNDArray(t);
+ case type::Descriptor::eMatrix:
+ return v.visitMatrix(t);
+ case type::Descriptor::eOrientation:
+ return v.visitOrientation(t);
+ case type::Descriptor::eImage:
+ return v.visitImage(t);
+ case type::Descriptor::ePointCloud:
+ return v.visitPointCloud(t);
+ case type::Descriptor::ePosition:
+ return v.visitPosition(t);
+ case type::Descriptor::ePose:
+ return v.visitPose(t);
+ case type::Descriptor::eQuaternion:
+ return v.visitQuaternion(t);
+ case type::Descriptor::eInt:
+ return v.visitInt(t);
+ case type::Descriptor::eLong:
+ return v.visitLong(t);
+ case type::Descriptor::eFloat:
+ return v.visitFloat(t);
+ case type::Descriptor::eDouble:
+ return v.visitDouble(t);
+ case type::Descriptor::eString:
+ return v.visitString(t);
+ case type::Descriptor::eBool:
+ return v.visitBool(t);
+ case type::Descriptor::eTime:
+ return v.visitTime(t);
+ case type::Descriptor::eIntEnum:
+ return v.visitIntEnum(t);
+ case type::Descriptor::eUnknown:
+ return v.visitUnknown(t);
+ }
+ }
+
+ /**
+ * @brief The RecursiveVisitor struct. It differs from the Visitor struct (@see Visitor.h), because it provides special visitXOnEnter and visitXOnExit methods for container types.
+ * Further, it defines abstract methods to get the children from the input representation which is used by the visitRecursive method.
+ */
+ template <class T>
+ struct RecursiveVisitor : virtual public VisitorBase<T>
+ {
+ using Input = typename VisitorBase<T>::Input;
+ using InputNonConst = typename std::remove_const<Input>::type;
+
+ virtual std::map<std::string, InputNonConst> getObjectAcceptedTypes(Input&) = 0;
+ virtual InputNonConst getDictAcceptedType(Input&) = 0;
+ virtual InputNonConst getListAcceptedType(Input&) = 0;
+ virtual std::pair<InputNonConst, InputNonConst> getPairAcceptedTypes(Input&) = 0;
+ virtual std::vector<InputNonConst> getTupleAcceptedTypes(Input&) = 0;
+
+ virtual void visitObjectOnEnter(Input&) {};
+ virtual void visitObjectOnExit(Input&) {};
+ virtual void visitDictOnEnter(Input&) {};
+ virtual void visitDictOnExit(Input&) {};
+ virtual void visitPairOnEnter(Input&) {};
+ virtual void visitPairOnExit(Input&) {};
+ virtual void visitTupleOnEnter(Input&) {};
+ virtual void visitTupleOnExit(Input&) {};
+ virtual void visitListOnEnter(Input&) {};
+ virtual void visitListOnExit(Input&) {};
+
+ virtual void visitMatrix(Input&) {};
+ virtual void visitNDArray(Input&) {};
+ virtual void visitQuaternion(Input&) {};
+ virtual void visitOrientation(Input&) {};
+ virtual void visitPosition(Input&) {};
+ virtual void visitPose(Input&) {};
+ virtual void visitImage(Input&) {};
+ virtual void visitPointCloud(Input&) {};
+ virtual void visitIntEnum(Input&) {};
+ virtual void visitInt(Input&) {};
+ virtual void visitLong(Input&) {};
+ virtual void visitFloat(Input&) {};
+ virtual void visitDouble(Input&) {};
+ virtual void visitBool(Input&) {};
+ virtual void visitString(Input&) {};
+ virtual void visitTime(Input&) {};
+ virtual void visitUnknown(Input&) {
+ throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor.");
+ }
+ virtual ~RecursiveVisitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/Visitor.cpp
similarity index 94%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.cpp
rename to source/RobotAPI/libraries/aron/core/type/visitor/Visitor.cpp
index d5dc077b9751440762c98533d41498cfe6f8c9c9..e4e806a53bd0308401db83a839544fee13e1d03b 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/Visitor.cpp
@@ -22,4 +22,9 @@
*/
// Header
-#include "ContainerSerializerBase.h"
+#include "Visitor.h"
+
+namespace armarx::aron::type
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/Visitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/Visitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..3978c029a5f5884acd89bea4d664ed928774bdfb
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/Visitor.h
@@ -0,0 +1,137 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "../../Descriptor.h"
+#include "../../Exception.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The visit function. Takes a visitor implementation as input and a type representation (e.g. aron::type::variant or nlohmann::json).
+ * Inspired by std::visit for std::variant
+ * This method only performs a single visit. This is useful if you only want to call a specific method depending on the type, or if you want to call a customized recursive function
+ * If you want to call a visitX recursively, please refer to "RecursiveVisitor.h"
+ */
+ template <class VisitorImplementation>
+ void visit(VisitorImplementation& v, typename VisitorImplementation::Input& t)
+ {
+ auto descriptor = v.getDescriptor(t);
+ switch (descriptor)
+ {
+ case type::Descriptor::eObject:
+ return v.visitObject(t);
+ case type::Descriptor::eList:
+ return v.visitList(t);
+ case type::Descriptor::eDict:
+ return v.visitDict(t);
+ case type::Descriptor::ePair:
+ return v.visitPair(t);
+ case type::Descriptor::eTuple:
+ return v.visitTuple(t);
+ case type::Descriptor::eNDArray:
+ return v.visitNDArray(t);
+ case type::Descriptor::eMatrix:
+ return v.visitMatrix(t);
+ case type::Descriptor::eOrientation:
+ return v.visitOrientation(t);
+ case type::Descriptor::eImage:
+ return v.visitImage(t);
+ case type::Descriptor::ePointCloud:
+ return v.visitPointCloud(t);
+ case type::Descriptor::ePosition:
+ return v.visitPosition(t);
+ case type::Descriptor::ePose:
+ return v.visitPose(t);
+ case type::Descriptor::eQuaternion:
+ return v.visitQuaternion(t);
+ case type::Descriptor::eInt:
+ return v.visitInt(t);
+ case type::Descriptor::eLong:
+ return v.visitLong(t);
+ case type::Descriptor::eFloat:
+ return v.visitFloat(t);
+ case type::Descriptor::eDouble:
+ return v.visitDouble(t);
+ case type::Descriptor::eString:
+ return v.visitString(t);
+ case type::Descriptor::eBool:
+ return v.visitBool(t);
+ case type::Descriptor::eTime:
+ return v.visitTime(t);
+ case type::Descriptor::eIntEnum:
+ return v.visitIntEnum(t);
+ case type::Descriptor::eUnknown:
+ return v.visitUnknown(t);
+ }
+ }
+
+ /**
+ * @brief The VisitorBase struct. Defines basic methods and typedefs for all visitors
+ */
+ template <class T>
+ struct VisitorBase
+ {
+ using Input = T;
+
+ virtual type::Descriptor getDescriptor(Input&) = 0;
+ virtual ~VisitorBase() = default;
+ };
+
+ /**
+ * @brief The Visitor struct. Defines the visitX methods a visitor has to impelement
+ */
+ template <class T>
+ struct Visitor : virtual public VisitorBase<T>
+ {
+ using Input = typename VisitorBase<T>::Input;
+ virtual void visitObject(Input&) {};
+ virtual void visitDict(Input&) {};
+ virtual void visitPair(Input&) {};
+ virtual void visitTuple(Input&) {};
+ virtual void visitList(Input&) {};
+ virtual void visitMatrix(Input&) {};
+ virtual void visitNDArray(Input&) {};
+ virtual void visitQuaternion(Input&) {};
+ virtual void visitOrientation(Input&) {};
+ virtual void visitPosition(Input&) {};
+ virtual void visitPose(Input&) {};
+ virtual void visitImage(Input&) {};
+ virtual void visitPointCloud(Input&) {};
+ virtual void visitIntEnum(Input&) {};
+ virtual void visitInt(Input&) {};
+ virtual void visitLong(Input&) {};
+ virtual void visitFloat(Input&) {};
+ virtual void visitDouble(Input&) {};
+ virtual void visitBool(Input&) {};
+ virtual void visitString(Input&) {};
+ virtual void visitTime(Input&) {};
+ virtual void visitUnknown(Input&) { throw error::AronException(__PRETTY_FUNCTION__, "Unknown type in visitor."); }
+ virtual ~Visitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6b2175d223a59338b77521a0f07c289ce598eca9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "NlohmannJSONVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.h b/source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.h
similarity index 57%
rename from source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.h
rename to source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.h
index 9c19b29f73e092b7e7e4330e2215301be2849674..08a7060d02132fd3c1fb0c3686e7c96a0780ba07 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Double.h
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/nlohmannJSON/NlohmannJSONVisitor.h
@@ -23,28 +23,32 @@
#pragma once
-// STD/STL
+#include <map>
#include <string>
+#include <vector>
-// Base class
-#include "../detail/PrimitiveNavigatorBase.h"
+// SImox
+#include <SimoxUtility/json.h>
-namespace armarx::aron::typenavigator
-{
- class DoubleNavigator;
- typedef std::shared_ptr<DoubleNavigator> DoubleNavigatorPtr;
+#include "../Visitor.h"
+#include "../../../Descriptor.h"
+#include "../../rw/json/Data.h"
- class DoubleNavigator :
- virtual public detail::PrimitiveNavigatorBase<type::AronDouble, DoubleNavigator>
+namespace armarx::aron::type
+{
+ /**
+ * @brief The NlohmannJSONVisitor struct. Already implements the method to get the descriptor of a nlohmann::json
+ */
+ struct NlohmannJSONVisitor : virtual public Visitor<const nlohmann::json>
{
- public:
- /* constructors */
- DoubleNavigator(const Path& = Path());
- DoubleNavigator(const type::AronDoublePtr&, const Path& = Path());
+ virtual type::Descriptor getDescriptor(Input& n) override
+ {
+ std::string t = n[armarx::aron::type::rw::json::constantes::TYPE_SLUG];
+ return armarx::aron::type::rw::json::conversion::String2Descriptor.at(t);
+ }
- type::AronDoublePtr toAronDoublePtr() const;
-
- /* virtual implementations */
- virtual std::string getName() const override;
+ virtual ~NlohmannJSONVisitor() = default;
};
+
+ // TODO
}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..005f9110566e3e90b6cd28d88d688ad00b51a09c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
@@ -0,0 +1,30 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// Header
+#include "VariantVisitor.h"
+
+namespace armarx::aron::data
+{
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b8bd1aeaf4959a5d13b34d37e44c7aaad7d8dff
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
@@ -0,0 +1,85 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "../RecursiveVisitor.h"
+#include "../../variant/All.h"
+
+namespace armarx::aron::type
+{
+ /**
+ * @brief The VariantVisitor struct. Already implements the method to get the descriptor of an aron variant.
+ */
+ struct VariantVisitor : virtual public Visitor<const type::VariantPtr>
+ {
+ virtual type::Descriptor getDescriptor(Input& n) override
+ {
+ return n->getDescriptor();
+ }
+ virtual ~VariantVisitor() = default;
+ };
+
+ /**
+ * @brief The RecursiveVariantVisitor struct. Already implements the methods to get the descriptor and children of an aron variant
+ */
+ struct RecursiveVariantVisitor : virtual public RecursiveVisitor<const type::VariantPtr>
+ {
+ virtual type::Descriptor getDescriptor(Input& n) override
+ {
+ return n->getDescriptor();
+ }
+
+ virtual std::map<std::string, type::VariantPtr> getObjectAcceptedTypes(Input& t) override
+ {
+ auto o = type::Object::DynamicCastAndCheck(t);
+ return o->getMemberTypes();
+ }
+ virtual type::VariantPtr getDictAcceptedType(Input& t) override
+ {
+ auto o = type::Dict::DynamicCastAndCheck(t);
+ return o->getAcceptedType();
+ }
+ virtual type::VariantPtr getListAcceptedType(Input& t) override
+ {
+ auto o = type::List::DynamicCastAndCheck(t);
+ return o->getAcceptedType();
+ }
+ virtual std::pair<type::VariantPtr, type::VariantPtr> getPairAcceptedTypes(Input& t) override
+ {
+ auto o = type::Pair::DynamicCastAndCheck(t);
+ return o->getAcceptedTypes();
+ }
+ virtual std::vector<type::VariantPtr> getTupleAcceptedTypes(Input& t) override
+ {
+ auto o = type::Tuple::DynamicCastAndCheck(t);
+ return o->getAcceptedTypes();
+ }
+
+ virtual ~RecursiveVariantVisitor() = default;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/Reader.h b/source/RobotAPI/libraries/aron/core/typereader/Reader.h
similarity index 59%
rename from source/RobotAPI/libraries/aron/core/codegenerator/typeReader/Reader.h
rename to source/RobotAPI/libraries/aron/core/typereader/Reader.h
index c65d64893b4ecc86f2c5b97a7bc7be5cdbb18ff0..c5e7b72347c0fe22541649c61305c3aff0962eed 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/Reader.h
+++ b/source/RobotAPI/libraries/aron/core/typereader/Reader.h
@@ -28,26 +28,28 @@
#include <filesystem>
// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/GenerateTypeInfo.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/ReaderInfo.h>
+#include <RobotAPI/libraries/aron/core/codegenerator/helper/WriterInfo.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h>
namespace armarx::aron::typereader
{
- template <typename Input>
- class Reader;
-
- template <typename Input>
- using ReaderPtr = std::shared_ptr<Reader<Input>>;
-
+ /**
+ * @brief The basic reader class, defining methods for reading an aron description file and returning an aron type object, representing the description
+ * It contains basic functions, to read in arbitrary files and to store the type generation information
+ */
template <typename Input>
class Reader
{
public:
Reader() = default;
+ /// parse a filename
virtual void parseFile(const std::string& filename) = 0;
+
+ /// path a file given by std::filesystem
virtual void parseFile(const std::filesystem::path& file) = 0;
std::vector<std::string> getCodeIncludes() const
@@ -58,19 +60,19 @@ namespace armarx::aron::typereader
{
return aronIncludes;
}
- std::vector<codegeneratorhelper::WriterInfoPtr> getWriters() const
+ std::vector<codegenerator::WriterInfo> getWriters() const
{
return writers;
}
- std::vector<codegeneratorhelper::ReaderInfoPtr> getReaders() const
+ std::vector<codegenerator::ReaderInfo> getReaders() const
{
return readers;
}
- std::vector<codegeneratorhelper::GenerateObjectInfoPtr> getGenerateObjects() const
+ std::vector<typereader::GenerateObjectInfo> getGenerateObjects() const
{
return generateObjects;
}
- std::vector<codegeneratorhelper::GenerateIntEnumInfoPtr> getGenerateIntEnums() const
+ std::vector<typereader::GenerateIntEnumInfo> getGenerateIntEnums() const
{
return generateIntEnums;
}
@@ -80,9 +82,11 @@ namespace armarx::aron::typereader
std::vector<std::string> codeIncludes;
std::vector<std::string> aronIncludes;
- std::vector<codegeneratorhelper::ReaderInfoPtr> readers;
- std::vector<codegeneratorhelper::WriterInfoPtr> writers;
- std::vector<codegeneratorhelper::GenerateIntEnumInfoPtr> generateIntEnums;
- std::vector<codegeneratorhelper::GenerateObjectInfoPtr> generateObjects;
+
+ std::vector<codegenerator::ReaderInfo> readers;
+ std::vector<codegenerator::WriterInfo> writers;
+
+ std::vector<typereader::GenerateIntEnumInfo> generateIntEnums;
+ std::vector<typereader::GenerateObjectInfo> generateObjects;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateInfo.h
similarity index 75%
rename from source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h
rename to source/RobotAPI/libraries/aron/core/typereader/helper/GenerateInfo.h
index baf4be57effcf3bff72b53ad4bf5a668ee471990..ad22e564e7ac734cae64a329c841004cae38d8f2 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/detail/ContainerSerializerBase.h
+++ b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateInfo.h
@@ -23,18 +23,18 @@
#pragma once
-#include "SerializerBase.h"
+// STD/STL
+#include <memory>
+#include <string>
-
-namespace armarx::aron::cppserializer::detail
+namespace armarx::aron::typereader
{
- template<typename TypenavigatorT, typename DerivedT>
- class ContainerSerializerBase :
- public SerializerBase<TypenavigatorT, DerivedT>
+ /// A top-level struct for type-generation information
+ struct GenerateInfo
{
- public:
-
- using SerializerBase<TypenavigatorT, DerivedT>::SerializerBase;
-
+ std::string typeName;
+ std::string definedIn;
+ std::string doc_brief;
+ std::string doc_author;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/GenerateIntEnumInfo.h b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h
similarity index 70%
rename from source/RobotAPI/libraries/aron/core/codegenerator/GenerateIntEnumInfo.h
rename to source/RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h
index e382b24225fc051ce7f8b402d73a640ec783b5ab..e6d92157f9ffc31bf2864bc1cae77927cb9951bf 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/GenerateIntEnumInfo.h
+++ b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h
@@ -26,23 +26,20 @@
// STD/STL
#include <memory>
#include <string>
+#include <map>
+
+// BaseClass
+#include "GenerateInfo.h"
// ArmarX
-#include <RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.h>
+#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
-namespace armarx::aron::codegeneratorhelper
+namespace armarx::aron::typereader
{
- class GenerateIntEnumInfo;
- typedef std::shared_ptr<GenerateIntEnumInfo> GenerateIntEnumInfoPtr;
-
- class GenerateIntEnumInfo
+ /// Information which is needed to generate code for an int enum
+ struct GenerateIntEnumInfo : public GenerateInfo
{
- public:
- std::string typeName;
- std::string definedIn;
- std::string doc_brief;
- std::string doc_author;
std::map<std::string, std::string> doc_values;
- typenavigator::IntEnumNavigatorPtr correspondingType;
+ type::IntEnumPtr correspondingType;
};
}
diff --git a/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..895a1a59df583f4181a25516d2adf9ce462fab51
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h
@@ -0,0 +1,43 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <string>
+
+#include "GenerateInfo.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+
+namespace armarx::aron::typereader
+{
+ /// Information which is needed to generate code for an object
+ struct GenerateObjectInfo : public GenerateInfo
+ {
+ std::map<std::string, std::string> doc_members;
+ type::ObjectPtr correspondingType;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/typereader/xml/Data.cpp b/source/RobotAPI/libraries/aron/core/typereader/xml/Data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1c84a04f5d16b5a06412092bc908c8ce65128154
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Data.cpp
@@ -0,0 +1,149 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#include "Data.h"
+
+#include <SimoxUtility/algorithm/string/string_tools.h>
+#include <RobotAPI/libraries/aron/core/Exception.h>
+
+namespace armarx::aron::typereader::xml
+{
+
+ std::optional<RapidXmlReaderNode> util::GetFirstNodeWithTag(const RapidXmlReaderNode& node, const std::string& name)
+ {
+ for (const auto& n : node.nodes())
+ {
+ if (HasTagName(n, name))
+ {
+ return n;
+ }
+ }
+
+ return std::nullopt;
+ }
+
+ void util::EnforceAttribute(const RapidXmlReaderNode& node, const std::string& att)
+ {
+ if (!HasAttribute(node, att))
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "A <" + node.name() + ">-tag does not have the correct attribute", att);
+ }
+ }
+
+ bool util::HasAttribute(const RapidXmlReaderNode& node, const std::string& att)
+ {
+ return node.has_attribute(att.c_str());
+ }
+
+ std::string util::GetAttribute(const RapidXmlReaderNode& node, const std::string& att)
+ {
+ EnforceAttribute(node, att);
+ return node.attribute_value(att.c_str());
+ }
+
+ std::string util::GetAttributeWithDefault(const armarx::RapidXmlReaderNode& node, const std::string& att, const std::string def)
+ {
+ if (!(HasAttribute(node, att)))
+ {
+ return def;
+ }
+ return node.attribute_value(att.c_str());
+ }
+
+ bool util::AttributeIsTrue(const armarx::RapidXmlReaderNode& node, const std::string& att)
+ {
+ if (HasAttribute(node, att))
+ {
+ std::string v = simox::alg::to_lower(node.attribute_value(att.c_str()));
+ if (v == "1" or v == "true" or v == "wahr" or v == "yes" or v == "ja" or v == "")
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool util::HasTagName(const armarx::RapidXmlReaderNode& node, const std::string& name)
+ {
+ return (simox::alg::to_lower(name) == simox::alg::to_lower(node.name()));
+ }
+
+ void util::EnforceTagName(const armarx::RapidXmlReaderNode& node, const std::string& name)
+ {
+ if (!(HasTagName(node, name)))
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong tag", name);
+ }
+ }
+
+ std::string util::GetTagName(const armarx::RapidXmlReaderNode& node)
+ {
+ return simox::alg::to_lower(node.name());
+ }
+
+ void util::EnforceChildSizeSmaller(const RapidXmlReaderNode& node, const size_t size)
+ {
+ const size_t s = node.nodes().size();
+ if (s >= size)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong number of children", std::to_string(s), std::to_string(size));
+ }
+ }
+
+ void util::EnforceChildSizeSmallerEqual(const RapidXmlReaderNode& node, const size_t size)
+ {
+ const size_t s = node.nodes().size();
+ if (s > size)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong number of children", std::to_string(s), std::to_string(size));
+ }
+ }
+
+ void util::EnforceChildSize(const armarx::RapidXmlReaderNode& node, const size_t size)
+ {
+ const size_t s = node.nodes().size();
+ if (s != size)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong number of children", std::to_string(s), std::to_string(size));
+ }
+ }
+
+ void util::EnforceChildSizeGreaterEqual(const RapidXmlReaderNode& node, const size_t size)
+ {
+ const size_t s = node.nodes().size();
+ if (s < size)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong number of children", std::to_string(s), std::to_string(size));
+ }
+ }
+
+ void util::EnforceChildSizeGreater(const RapidXmlReaderNode& node, const size_t size)
+ {
+ const size_t s = node.nodes().size();
+ if (s <= size)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The node <" + node.name() + "> has the wrong number of children", std::to_string(s), std::to_string(size));
+ }
+ }
+
+}
diff --git a/source/RobotAPI/libraries/aron/core/typereader/xml/Data.h b/source/RobotAPI/libraries/aron/core/typereader/xml/Data.h
new file mode 100644
index 0000000000000000000000000000000000000000..2fdda0b29d766300ae6364bdacf3ab3a855614a3
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Data.h
@@ -0,0 +1,127 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <map>
+
+// ArmarX
+#include <SimoxUtility/xml.h>
+#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
+
+/**
+ * All constantes for the aron XML parser, in addition to some utility functions wrapping around the armarxcore-xml-parser
+ */
+namespace armarx::aron::typereader::xml
+{
+ namespace constantes
+ {
+ // Definition tags
+ const std::string TYPE_DEFINITION_TAG = "arontypedefinition";
+
+ const std::string CODE_INCLUDES_TAG = "codeincludes";
+ const std::string INCLUDES_TAG = "aronincludes";
+ const std::string GENERATE_TYPES_TAG = "generatetypes";
+ const std::string AUTO_CODE_INCLUDE = "autoinclude";
+
+ const std::string INCLUDE_TAG = "include";
+
+ // Attribute names
+ const std::string METHOD_ATTRIBUTE_NAME = "method";
+ const std::string RETURN_ATTRIBUTE_NAME = "return";
+ const std::string ARGUMENT_TYPE_ATTRIBUTE_NAME = "argumenttype";
+ const std::string INCLUDE_ATTRIBUTE_NAME = "include";
+ const std::string READER_ATTRIBUTE_NAME = "reader";
+ const std::string WRITER_ATTRIBUTE_NAME = "writer";
+ const std::string EXTENDS_ATTRIBUTE_NAME = "extends";
+ const std::string NAME_ATTRIBUTE_NAME = "name";
+ const std::string VALUE_ATTRIBUTE_NAME = "value";
+ const std::string KEY_ATTRIBUTE_NAME = "key";
+ const std::string TYPE_ATTRIBUTE_NAME = "type";
+ const std::string WIDTH_ATTRIBUTE_NAME = "width";
+ const std::string HEIGHT_ATTRIBUTE_NAME = "height";
+ const std::string ROWS_ATTRIBUTE_NAME = "rows";
+ const std::string COLS_ATTRIBUTE_NAME = "cols";
+ const std::string DIMENSIONS_ATTRIBUTE_NAME = "dimensions";
+ const std::string SHAPE_ATTRIBUTE_NAME = "shape";
+ const std::string OPTIONAL_NAME = "optional";
+ const std::string RAW_PTR_NAME = "raw_ptr";
+ const std::string SHARED_PTR_NAME = "shared_ptr";
+ const std::string UNIQUE_PTR_NAME = "unique_ptr";
+ const std::string PACKAGE_NAME = "package";
+ const std::string DOC_BRIEF_NAME = "doc-brief";
+ const std::string DOC_AUTHOR_NAME = "doc-author";
+ const std::string DOC_PARAM_NAME = "doc-param";
+
+ // Second level tags. Only important if in specific top level tag
+ const std::string OBJECT_CHILD_TAG = "objectchild";
+ const std::string ENUM_VALUE_TAG = "enumvalue";
+
+ // Top Level type tags
+ const std::string LIST_TAG = "list";
+ const std::string DICT_TAG = "dict";
+ const std::string OBJECT_TAG = "object";
+ const std::string PAIR_TAG = "pair";
+ const std::string TUPLE_TAG = "tuple";
+ const std::string INT_ENUM_TAG = "intenum";
+ const std::string NDARRAY_TAG = "ndarray";
+ const std::string MATRIX_TAG = "matrix";
+ const std::string QUATERNION_TAG = "quaternion";
+ const std::string IMAGE_TAG = "image";
+ const std::string POINT_CLOUD_TAG = "pointcloud";
+ const std::string POSITION_TAG = "position";
+ const std::string ORIENTATION_TAG = "orientation";
+ const std::string POSE_TAG = "pose";
+ const std::string INT_TAG = "int";
+ const std::string LONG_TAG = "long";
+ const std::string FLOAT_TAG = "float";
+ const std::string DOUBLE_TAG = "double";
+ const std::string STRING_TAG = "string";
+ const std::string BOOL_TAG = "bool";
+ const std::string TIME_TAG = "time";
+ }
+
+
+ namespace util
+ {
+ std::optional<RapidXmlReaderNode> GetFirstNodeWithTag(const RapidXmlReaderNode& node, const std::string& name);
+
+ void EnforceAttribute(const RapidXmlReaderNode& node, const std::string& att);
+ bool HasAttribute(const RapidXmlReaderNode& node, const std::string& att);
+ std::string GetAttribute(const RapidXmlReaderNode& node, const std::string& att);
+ std::string GetAttributeWithDefault(const RapidXmlReaderNode& node, const std::string& att, const std::string def);
+ bool AttributeIsTrue(const RapidXmlReaderNode& node, const std::string& att);
+
+ bool HasTagName(const RapidXmlReaderNode& node, const std::string& name);
+ void EnforceTagName(const RapidXmlReaderNode& node, const std::string& name);
+ std::string GetTagName(const RapidXmlReaderNode& node);
+
+ void EnforceChildSizeSmaller(const RapidXmlReaderNode& node, const size_t size);
+ void EnforceChildSizeSmallerEqual(const RapidXmlReaderNode& node, const size_t size);
+ void EnforceChildSize(const RapidXmlReaderNode& node, const size_t size);
+ void EnforceChildSizeGreaterEqual(const RapidXmlReaderNode& node, const size_t size);
+ void EnforceChildSizeGreater(const RapidXmlReaderNode& node, const size_t size);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.cpp b/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bffc30376046d6eae82a9e8aedc412d93645b6db
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.cpp
@@ -0,0 +1,503 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+// STD/STL
+
+// Simox
+#include <SimoxUtility/algorithm/string.h>
+
+// Header
+#include "Factory.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/type/variant/All.h>
+#include "Data.h"
+
+namespace armarx::aron::typereader::xml
+{
+ std::map<std::string, typereader::GenerateObjectInfo> ReaderFactory::AllGeneratedPublicObjects;
+ std::map<std::string, typereader::GenerateIntEnumInfo> ReaderFactory::AllGeneratedPublicIntEnums;
+
+ type::VariantPtr ReaderFactory::create(const RapidXmlReaderNode& node, const Path& path)
+ {
+ static const std::map<std::string, type::Descriptor> String2Descriptor =
+ {
+ {constantes::LIST_TAG, type::Descriptor::eList},
+ {constantes::OBJECT_TAG, type::Descriptor::eObject},
+ {constantes::TUPLE_TAG, type::Descriptor::eTuple},
+ {constantes::PAIR_TAG, type::Descriptor::ePair},
+ {constantes::DICT_TAG, type::Descriptor::eDict},
+ {constantes::NDARRAY_TAG, type::Descriptor::eNDArray},
+ {constantes::MATRIX_TAG, type::Descriptor::eMatrix},
+ {constantes::QUATERNION_TAG, type::Descriptor::eQuaternion},
+ {constantes::POINT_CLOUD_TAG, type::Descriptor::ePointCloud},
+ {constantes::POSITION_TAG, type::Descriptor::ePosition},
+ {constantes::ORIENTATION_TAG, type::Descriptor::eOrientation},
+ {constantes::POSE_TAG, type::Descriptor::ePose},
+ {constantes::IMAGE_TAG, type::Descriptor::eImage},
+ {constantes::INT_ENUM_TAG, type::Descriptor::eIntEnum},
+ {constantes::INT_TAG, type::Descriptor::eInt},
+ {constantes::LONG_TAG, type::Descriptor::eLong},
+ {constantes::FLOAT_TAG, type::Descriptor::eFloat},
+ {constantes::DOUBLE_TAG, type::Descriptor::eDouble},
+ {constantes::STRING_TAG, type::Descriptor::eString},
+ {constantes::BOOL_TAG, type::Descriptor::eBool},
+ {constantes::TIME_TAG, type::Descriptor::eTime}
+ };
+
+ const std::string tag = simox::alg::to_lower(node.name());
+ auto it = String2Descriptor.find(tag);
+ auto descriptor = (it == String2Descriptor.end() ? type::Descriptor::eUnknown : it->second);
+
+ switch(descriptor)
+ {
+ case type::Descriptor::eList: return createList(node, path);
+ case type::Descriptor::eDict: return createDict(node, path);
+ case type::Descriptor::eObject: return createObject(node, path);
+ case type::Descriptor::eTuple: return createTuple(node, path);
+ case type::Descriptor::ePair: return createPair(node, path);
+ case type::Descriptor::eNDArray: return createNDArray(node, path);
+ case type::Descriptor::eMatrix: return createMatrix(node, path);
+ case type::Descriptor::eQuaternion: return createQuaternion(node, path);
+ case type::Descriptor::eImage: return createImage(node, path);
+ case type::Descriptor::ePointCloud: return createPointCloud(node, path);
+ case type::Descriptor::ePosition: return createPosition(node, path);
+ case type::Descriptor::eOrientation: return createOrientation(node, path);
+ case type::Descriptor::ePose: return createPose(node, path);
+ case type::Descriptor::eIntEnum: return createIntEnum(node, path);
+ case type::Descriptor::eInt: return createInt(node, path);
+ case type::Descriptor::eLong: return createLong(node, path);
+ case type::Descriptor::eFloat: return createFloat(node, path);
+ case type::Descriptor::eDouble: return createDouble(node, path);
+ case type::Descriptor::eString: return createString(node, path);
+ case type::Descriptor::eBool: return createBool(node, path);
+ case type::Descriptor::eTime: return createTime(node, path);
+ default: return findExistingObject(node.name());
+ }
+ }
+
+ type::VariantPtr ReaderFactory::findExistingObject(const std::string& n) const
+ {
+ auto name = simox::alg::to_lower(n);
+ const auto public_intenum_it = AllGeneratedPublicIntEnums.find(name);
+ if (public_intenum_it != AllGeneratedPublicIntEnums.end())
+ {
+ // copy the navigator
+ auto v = type::Variant::FromAronDTO(*public_intenum_it->second.correspondingType->toAronDTO());
+ return v;
+ }
+
+ const auto public_obj_it = AllGeneratedPublicObjects.find(name);
+ if (public_obj_it != AllGeneratedPublicObjects.end())
+ {
+ // copy the navigator
+ auto v = type::Variant::FromAronDTO(*public_obj_it->second.correspondingType->toAronDTO());
+ return v;
+ }
+
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Cannot find a valid object.", name);
+ }
+
+ type::Maybe ReaderFactory::getMaybe(const RapidXmlReaderNode& n) const
+ {
+ if (util::AttributeIsTrue(n, constantes::OPTIONAL_NAME))
+ {
+ return type::Maybe::eOptional;
+ }
+ if (util::AttributeIsTrue(n, constantes::RAW_PTR_NAME))
+ {
+ return type::Maybe::eRawPointer;
+ }
+ if (util::AttributeIsTrue(n, constantes::SHARED_PTR_NAME))
+ {
+ return type::Maybe::eSharedPointer;
+ }
+ if (util::AttributeIsTrue(n, constantes::UNIQUE_PTR_NAME))
+ {
+ return type::Maybe::eUniquePointer;
+ }
+ return type::Maybe::eNone;
+ }
+
+ void ReaderFactory::checkObjectMemberName(const std::string& s) const
+ {
+ if (simox::alg::starts_with(s, "_") || simox::alg::ends_with(s, "_"))
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "You used an invalid membername - '_' as starting or ending char is not allowed.", s);
+ }
+
+ if (simox::alg::starts_with(s, "aron"))
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "You used an invalid membername - The prefix 'aron' is used for codegeneration.", s);
+ }
+ }
+
+ type::VariantPtr ReaderFactory::createObject(const RapidXmlReaderNode& node, const Path& path)
+ {
+ if (path.hasElement())
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Having an inner class is not supported anymore since Aron Version 'beta 0.2.3'. Please move the inner class definition to the <" + constantes::GENERATE_TYPES_TAG + ">-tag.");
+ }
+
+ util::EnforceAttribute(node, constantes::NAME_ATTRIBUTE_NAME);
+ const std::string extends = util::GetAttributeWithDefault(node, constantes::EXTENDS_ATTRIBUTE_NAME, "");
+ const std::string name = util::GetAttribute(node, constantes::NAME_ATTRIBUTE_NAME);
+
+ auto newObject = typereader::GenerateObjectInfo();
+ newObject.typeName = name;
+ newObject.doc_brief = util::GetAttributeWithDefault(node, constantes::DOC_BRIEF_NAME, "");
+ newObject.doc_author = util::GetAttributeWithDefault(node, constantes::DOC_AUTHOR_NAME, "");
+
+ std::map<std::string, type::VariantPtr> members;
+ for (const RapidXmlReaderNode& objectChild : node.nodes())
+ {
+ util::EnforceTagName(objectChild, constantes::OBJECT_CHILD_TAG);
+ util::EnforceChildSize(objectChild, 1);
+
+ util::EnforceAttribute(objectChild, constantes::KEY_ATTRIBUTE_NAME);
+ const std::string key = util::GetAttribute(objectChild, constantes::KEY_ATTRIBUTE_NAME);
+
+ checkObjectMemberName(key);
+
+ if (util::HasAttribute(objectChild, constantes::DOC_BRIEF_NAME))
+ {
+ newObject.doc_members.insert({key, util::GetAttribute(objectChild, constantes::DOC_BRIEF_NAME)});
+ }
+
+ std::vector<RapidXmlReaderNode> children = objectChild.nodes();
+
+ auto maybe = getMaybe(children[0]);
+ type::VariantPtr childNavigator = create(children[0], Path(path, key));
+
+ childNavigator->setMaybe(maybe);
+ members.insert({key, childNavigator});
+ }
+
+ // set the new object
+ auto aronObjectType = std::make_shared<type::Object>(name, members, path);
+
+ if (extends != "")
+ {
+ auto parentObj = type::Object::DynamicCastAndCheck(findExistingObject(simox::alg::to_lower(extends)));
+ aronObjectType->setExtends(parentObj);
+ }
+
+ newObject.correspondingType = aronObjectType;
+ AllGeneratedPublicObjects.emplace(simox::alg::to_lower(newObject.typeName), newObject);
+ return aronObjectType;
+ }
+
+ type::VariantPtr ReaderFactory::createList(const RapidXmlReaderNode &node, const Path &path)
+ {
+ util::EnforceChildSize(node, 1);
+
+ std::vector<RapidXmlReaderNode> c = node.nodes();
+ const RapidXmlReaderNode typeNode = c[0];
+ type::VariantPtr type = create(typeNode, Path(path, "[accepted-type]"));
+ type->setMaybe(getMaybe(typeNode));
+
+ auto o = std::make_shared<type::List>(type, path);
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createDict(const RapidXmlReaderNode &node, const Path &path)
+ {
+ util::EnforceChildSize(node, 1);
+
+ std::vector<RapidXmlReaderNode> c = node.nodes();
+ const RapidXmlReaderNode typeNode = c[0];
+ type::VariantPtr type = create(typeNode, Path(path, "type"));
+ type->setMaybe(getMaybe(typeNode));
+
+ auto o = std::make_shared<type::Dict>(type, path);
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createTuple(const RapidXmlReaderNode& node, const Path& path)
+ {
+ util::EnforceChildSizeGreater(node, 1);
+
+ unsigned int i = 0;
+ std::vector<RapidXmlReaderNode> c = node.nodes();
+ std::vector<type::VariantPtr> elementTypes;
+ for (const RapidXmlReaderNode& tupleTypeDeclarationNode : c)
+ {
+ util::EnforceChildSize(tupleTypeDeclarationNode, 1);
+
+ std::vector<RapidXmlReaderNode> typeNodeChildren = tupleTypeDeclarationNode.nodes();
+ const RapidXmlReaderNode typeNode = typeNodeChildren[0];
+
+ type::VariantPtr type = create(typeNode, Path(path, "<" + std::to_string(i++) + ">"));
+ type->setMaybe(getMaybe(typeNode));
+
+ elementTypes.push_back(type);
+ }
+
+ auto o = std::make_shared<type::Tuple>(elementTypes, path);
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createPair(const RapidXmlReaderNode& node, const Path& path)
+ {
+ util::EnforceChildSize(node, 2);
+
+ std::vector<RapidXmlReaderNode> c = node.nodes();
+ const RapidXmlReaderNode type1Node = c[0];
+
+ type::VariantPtr type1 = create(type1Node, Path(path, std::to_string(0)));
+ type1->setMaybe(getMaybe(type1Node));
+
+ const RapidXmlReaderNode type2Node = c[1];
+ type::VariantPtr type2 = create(type2Node, Path(path, std::to_string(1)));
+ type2->setMaybe(getMaybe(type2Node));
+
+ auto o = std::make_shared<type::Pair>(type1, type2, path);
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createNDArray(const RapidXmlReaderNode& node, const Path& path) const
+ {
+ static const std::map<std::string, type::ndarray::ElementType> String2NDArrayType =
+ {
+ {"int8", type::ndarray::ElementType::int8},
+ {"int16", type::ndarray::ElementType::int16},
+ {"int32", type::ndarray::ElementType::int32},
+ {"uint8", type::ndarray::ElementType::uint8},
+ {"uint16", type::ndarray::ElementType::uint16},
+ {"uint32", type::ndarray::ElementType::uint32},
+ {"float32", type::ndarray::ElementType::float32},
+ {"float64", type::ndarray::ElementType::float64}
+ };
+
+ return nullptr;
+ }
+
+ type::VariantPtr ReaderFactory::createMatrix(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ static const std::map<std::string, type::matrix::ElementType> String2MatrixType =
+ {
+ {"int16", type::matrix::ElementType::int16},
+ {"int32", type::matrix::ElementType::int32},
+ {"int64", type::matrix::ElementType::int64},
+ {"float32", type::matrix::ElementType::float32},
+ {"float64", type::matrix::ElementType::float64}
+ };
+
+ auto o = std::make_shared<type::Matrix>(path);
+ util::EnforceChildSize(node, 0);
+ util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
+
+ const int rows = std::stoi(util::GetAttributeWithDefault(node, constantes::ROWS_ATTRIBUTE_NAME, "4"));
+ const int cols = std::stoi(util::GetAttributeWithDefault(node, constantes::COLS_ATTRIBUTE_NAME, "4"));
+ std::string type = util::GetAttributeWithDefault(node, constantes::TYPE_ATTRIBUTE_NAME, "???");
+
+ o->setRows(rows);
+ o->setCols(cols);
+ try
+ {
+ o->setElementType(String2MatrixType.at(simox::alg::to_lower(type)));
+ }
+ catch (std::out_of_range& e)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The type tag is not valid", type);
+ }
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createQuaternion(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ static const std::map<std::string, type::quaternion::ElementType> String2QuaternionType =
+ {
+ {"float32", type::quaternion::ElementType::float32},
+ {"float64", type::quaternion::ElementType::float64}
+ };
+
+ auto o = std::make_shared<type::Quaternion>(path);
+ util::EnforceChildSize(node, 0);
+ util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
+
+ std::string type = util::GetAttributeWithDefault(node, constantes::TYPE_ATTRIBUTE_NAME, "???");
+
+ try
+ {
+ o->setElementType(String2QuaternionType.at(simox::alg::to_lower(type)));
+ }
+ catch (std::out_of_range& e)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The type tag is not valid", type);
+ }
+ return o;
+ }
+
+
+ type::VariantPtr ReaderFactory::createImage(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ static const std::map<std::string, type::image::PixelType> String2PixelType =
+ {
+ {"rgb24", type::image::PixelType::rgb24},
+ {"depth32", type::image::PixelType::depth32}
+ };
+
+ auto o = std::make_shared<type::Image>(path);
+ util::EnforceChildSize(node, 0);
+ util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
+
+ std::string type = util::GetAttributeWithDefault(node, constantes::TYPE_ATTRIBUTE_NAME, "???");
+
+ try
+ {
+ o->setPixelType(String2PixelType.at(simox::alg::to_lower(type)));
+ }
+ catch (std::out_of_range& e)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The type tag is not valid", type);
+ }
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createPointCloud(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ static const std::map<std::string, type::pointcloud::VoxelType> String2VoxelType =
+ {
+ {"pointxyz", type::pointcloud::VoxelType::PointXYZ},
+ {"pointxyzi", type::pointcloud::VoxelType::PointXYZI},
+ {"pointxyzl", type::pointcloud::VoxelType::PointXYZL},
+ {"pointxyzrgb", type::pointcloud::VoxelType::PointXYZRGB},
+ {"pointxyzrgbl", type::pointcloud::VoxelType::PointXYZRGBL},
+ {"pointxyzrgba", type::pointcloud::VoxelType::PointXYZRGBA},
+ {"pointxyzhsv", type::pointcloud::VoxelType::PointXYZHSV}
+ };
+
+ auto o = std::make_shared<type::PointCloud>(path);
+ util::EnforceChildSize(node, 0);
+ util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
+
+ std::string type = util::GetAttributeWithDefault(node, constantes::TYPE_ATTRIBUTE_NAME, "???");
+ try
+ {
+ o->setVoxelType(String2VoxelType.at(simox::alg::to_lower(type)));
+ }
+ catch (std::out_of_range& e)
+ {
+ throw error::ValueNotValidException(__PRETTY_FUNCTION__, "The type tag is not valid", type);
+ }
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createPosition(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ auto o = std::make_shared<type::Position>(path);
+ util::EnforceChildSize(node, 0);
+
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createOrientation(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ auto o = std::make_shared<type::Orientation>(path);
+ util::EnforceChildSize(node, 0);
+
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createPose(const RapidXmlReaderNode& node, const Path& path) const
+ {
+ auto o = std::make_shared<type::Pose>(path);
+ util::EnforceChildSize(node, 0);
+
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createIntEnum(const RapidXmlReaderNode& node, const Path& path)
+ {
+ if (path.hasElement())
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "Having an inner int-enum is not supported anymore since Aron Version 'beta 0.2.3'. Please move the inner int-enum definition to the <" + constantes::GENERATE_TYPES_TAG + ">-tag.");
+ }
+
+ const std::string name = util::GetAttribute(node, constantes::NAME_ATTRIBUTE_NAME);
+
+ auto newEnumInfo = typereader::GenerateIntEnumInfo();
+ newEnumInfo.typeName = name;
+
+ std::map<std::string, int> acceptedValues;
+ for (const RapidXmlReaderNode& valueChild : node.nodes())
+ {
+ util::EnforceTagName(valueChild, constantes::ENUM_VALUE_TAG);
+ util::EnforceChildSize(valueChild, 0);
+
+ const std::string key = util::GetAttribute(valueChild, constantes::KEY_ATTRIBUTE_NAME);
+
+ if (util::HasAttribute(valueChild, constantes::DOC_BRIEF_NAME))
+ {
+ newEnumInfo.doc_values.insert({key, util::GetAttribute(valueChild, constantes::DOC_BRIEF_NAME)});
+ }
+
+ const std::string value = util::GetAttribute(valueChild, constantes::VALUE_ATTRIBUTE_NAME);
+
+ acceptedValues.emplace(key, std::stoi(value));
+ }
+ auto o = std::make_shared<type::IntEnum>(name, acceptedValues, path);
+ newEnumInfo.correspondingType = o;
+
+ AllGeneratedPublicIntEnums.emplace(simox::alg::to_lower(newEnumInfo.typeName), newEnumInfo);
+
+
+ return o;
+ }
+
+ type::VariantPtr ReaderFactory::createInt(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Int>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createLong(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Long>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createFloat(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Float>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createDouble(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Double>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createString(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::String>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createBool(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Bool>(path);
+ }
+
+ type::VariantPtr ReaderFactory::createTime(const RapidXmlReaderNode &node, const Path &path) const
+ {
+ return std::make_shared<type::Time>(path);
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.h b/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.h
new file mode 100644
index 0000000000000000000000000000000000000000..33861a4baad98f57bc3401610a60cb22043f65b9
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Factory.h
@@ -0,0 +1,94 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
+ * Karlsruhe Institute of Technology (KIT), all rights reserved.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+// STD/STL
+#include <memory>
+#include <map>
+#include <vector>
+#include <stack>
+
+// ArmarX
+#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateTypeInfo.h>
+#include <RobotAPI/libraries/aron/core/typereader/helper/GenerateIntEnumInfo.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Variant.h>
+
+
+namespace armarx::aron::typereader::xml
+{
+ /**
+ * @brief The ReaderFactory class. It takes a xml-node and generates a type object representing the description in the xml node
+ */
+ class ReaderFactory
+ {
+ public:
+ ReaderFactory() = default;
+
+ /// the creation methods to return the types. Basically does a switch-case over the xml tag names converted to a descriptor object.
+ type::VariantPtr create(const RapidXmlReaderNode&, const Path&);
+
+ private:
+ /// check, whether a given name corresponds to an already created object name.
+ type::VariantPtr findExistingObject(const std::string& n) const;
+
+ /// check, if the type should be a maybe type
+ type::Maybe getMaybe(const RapidXmlReaderNode&) const;
+
+ /// check, if the member name matches the requirements
+ void checkObjectMemberName(const std::string&) const;
+
+
+ type::VariantPtr createObject(const RapidXmlReaderNode& node, const Path& path);
+ type::VariantPtr createList(const RapidXmlReaderNode& node, const Path& path);
+ type::VariantPtr createDict(const RapidXmlReaderNode& node, const Path& path);
+ type::VariantPtr createTuple(const RapidXmlReaderNode& node, const Path& path);
+ type::VariantPtr createPair(const RapidXmlReaderNode& node, const Path& path);
+ type::VariantPtr createIntEnum(const RapidXmlReaderNode& node, const Path& path);
+
+ type::VariantPtr createNDArray(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createMatrix(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createQuaternion(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createImage(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createPointCloud(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createPosition(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createOrientation(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createPose(const RapidXmlReaderNode& node, const Path& path) const;
+
+ type::VariantPtr createInt(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createLong(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createFloat(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createDouble(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createString(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createBool(const RapidXmlReaderNode& node, const Path& path) const;
+ type::VariantPtr createTime(const RapidXmlReaderNode& node, const Path& path) const;
+
+ public:
+ /// static map of all generated objects. Since this factory may be called recursively, it must be static
+ static std::map<std::string, typereader::GenerateObjectInfo> AllGeneratedPublicObjects;
+
+ /// same for int enums
+ static std::map<std::string, typereader::GenerateIntEnumInfo> AllGeneratedPublicIntEnums;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp b/source/RobotAPI/libraries/aron/core/typereader/xml/Reader.cpp
similarity index 50%
rename from source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp
rename to source/RobotAPI/libraries/aron/core/typereader/xml/Reader.cpp
index 7a89bb039550822a81f61e4ee1716f1e9c39688a..33ef52d8fb5f7cf1405a2c60361dacca7c7bf3bc 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Reader.cpp
@@ -31,14 +31,41 @@
#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
#include <ArmarXCore/core/system/cmake/CMakePackageFinder.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Data.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h>
+#include <RobotAPI/libraries/aron/core/typereader/xml/Data.h>
+#include <RobotAPI/libraries/aron/core/type/variant/Factory.h>
-namespace fs = std::filesystem;
-
-namespace armarx::aron::xmltypereader
+namespace armarx::aron::typereader::xml
{
+ namespace fs = std::filesystem;
+
+ namespace
+ {
+ /// Resolve a relative Package path. This may be removed in a newer version of aron
+ std::optional<fs::path> resolveRelativePackagePath(const fs::path& path)
+ {
+ const std::string package = *path.begin();
+ armarx::CMakePackageFinder finder(package);
+ if (finder.packageFound())
+ {
+ for (const std::string& includePath : finder.getIncludePathList())
+ {
+ fs::path absPath = includePath / path;
+ if (fs::is_regular_file(absPath))
+ {
+ // path is valid
+ return absPath;
+ }
+ }
+ return std::nullopt;
+ }
+ else
+ {
+ return std::nullopt;
+ }
+ }
+ }
+
void Reader::parseFile(const std::string& _filename)
{
std::string filename = _filename;
@@ -64,116 +91,71 @@ namespace armarx::aron::xmltypereader
RapidXmlReaderNode root = reader->getRoot();
// Check Header
- Data::EnforceTagName(root, Data::TYPE_DEFINITION_TAG);
+ util::EnforceTagName(root, constantes::TYPE_DEFINITION_TAG);
- Data::CheckMaxChildSize(root, 4);
- std::vector<RapidXmlReaderNode> children = root.nodes();
+ util::EnforceChildSizeSmallerEqual(root, 4);
- int cpp_includes_index = -1;
- int include_aron_file_index = -1;
- int generate_types_index = -1;
-
- int index = 0;
- for (const auto& child : children)
- {
- if (Data::HasTagName(child, Data::CODE_INCLUDES_TAG))
- {
- if (cpp_includes_index != -1)
- {
- throw error::AronException("XMLReader", "parse", "Already found an include tag. Please check the xml file.");
- }
- else
- {
- cpp_includes_index = index;
- }
- }
- else if (Data::HasTagName(child, Data::INCLUDES_TAG))
- {
- if (include_aron_file_index != -1)
- {
- throw error::AronException("XMLReader", "parse", "Already found an use type tag. Please check the xml file.");
- }
- else
- {
- include_aron_file_index = index;
- }
- }
- else if (Data::HasTagName(child, Data::GENERATE_TYPES_TAG))
- {
- if (generate_types_index != -1)
- {
- throw error::AronException("XMLReader", "parse", "Already found an generate type tag. Please check the xml file.");
- }
- else
- {
- generate_types_index = index;
- }
- }
- else
- {
- throw error::StringNotValidException("XMLReader", "parse", "Found an unexpected xml tag", child.name());
- }
- index++;
- }
+ auto code_includes = util::GetFirstNodeWithTag(root, constantes::CODE_INCLUDES_TAG);
+ auto aron_includes = util::GetFirstNodeWithTag(root, constantes::INCLUDES_TAG);
+ auto generate_types = util::GetFirstNodeWithTag(root, constantes::GENERATE_TYPES_TAG);
// 1. Check includes
- if (cpp_includes_index != -1)
+ if (code_includes.has_value())
{
- std::vector<RapidXmlReaderNode> includes = children[cpp_includes_index].nodes();
- for (const auto& include : includes)
+ for (const auto& include : (*code_includes).nodes())
{
this->codeIncludes.push_back(readCodeInclude(include, filePath));
}
}
// 2. Check AronIncludes
- if (include_aron_file_index != -1)
+ if (aron_includes.has_value())
{
- for (const auto& aronInclude : children[include_aron_file_index].nodes())
+ for (const auto& aronInclude : (*aron_includes).nodes())
{
- // right now unused
this->aronIncludes.push_back(readAronInclude(aronInclude, filePath));
}
}
// 3. Check GenerateTypes
- if (generate_types_index != -1)
+ if (generate_types.has_value())
{
- for (const auto& generateType : children[generate_types_index].nodes())
+ for (const auto& generateType : (*generate_types).nodes())
{
- // ugly workaround
- if (Data::HasTagName(generateType, Data::GENERATE_OBJECT_TAG))
+ if (util::HasTagName(generateType, constantes::OBJECT_TAG))
{
const auto nav = readGenerateObject(generateType);
- const auto infos = factory.AllPublicObjects;
- generateObjects.push_back(infos.at(simox::alg::to_lower(nav->getObjectName())));
+ generateObjects.push_back(factory.AllGeneratedPublicObjects.at(simox::alg::to_lower(nav->getObjectName())));
continue;
}
- if (Data::HasTagName(generateType, Data::GENERATE_INT_ENUM_TAG))
+
+ if (util::HasTagName(generateType, constantes::INT_ENUM_TAG))
{
const auto nav = readGenerateIntEnum(generateType);
- const auto infos = factory.AllPublicIntEnums;
- generateIntEnums.push_back(infos.at(simox::alg::to_lower(nav->getEnumName())));
+ generateIntEnums.push_back(factory.AllGeneratedPublicIntEnums.at(simox::alg::to_lower(nav->getEnumName())));
continue;
}
- throw error::StringNotValidException("XMLReader", "parse", "Could not find a valid tag inside generatetypes", generateType.name());
-
+ throw error::ValueNotValidException("XMLReader", "parse", "Could not find a valid tag inside generatetypes", generateType.name());
}
}
+ else
+ {
+ throw error::AronException(__PRETTY_FUNCTION__, "No generate types found in aron xml '" + filePath.string() + "'.");
+ }
}
std::string Reader::readCodeInclude(const RapidXmlReaderNode& node, const std::filesystem::path& filePath)
{
- Data::EnforceTagName(node, Data::INCLUDE_TAG);
- Data::EnforceAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
- const std::string include = node.attribute_value(Data::INCLUDE_ATTRIBUTE_NAME);
+ util::EnforceTagName(node, constantes::INCLUDE_TAG);
+ util::EnforceAttribute(node, constantes::INCLUDE_ATTRIBUTE_NAME);
+ const std::string include = util::GetAttribute(node, constantes::INCLUDE_ATTRIBUTE_NAME);
return include;
}
std::string Reader::readAronInclude(const RapidXmlReaderNode& node, const std::filesystem::path& filePath)
{
- Data::EnforceTagName(node, Data::INCLUDE_TAG);
- std::string specifiedPath = Data::GetAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
+ util::EnforceTagName(node, constantes::INCLUDE_TAG);
+ std::string specifiedPath = util::GetAttribute(node, constantes::INCLUDE_ATTRIBUTE_NAME);
specifiedPath = simox::alg::replace_all(specifiedPath, "<", "");
specifiedPath = simox::alg::replace_all(specifiedPath, ">", "");
const std::filesystem::path xmlincludepath(specifiedPath);
@@ -199,7 +181,7 @@ namespace armarx::aron::xmltypereader
if (!fs::is_regular_file(resolved_absolute_path))
{
- throw error::AronException("Reader", "readAronInclude", "Could not find an aron XML file. Last path tried was: " + resolved_absolute_path.string());
+ throw error::AronException(__PRETTY_FUNCTION__, "Could not find an aron XML file. Last path tried was: " + resolved_absolute_path.string());
}
}
}
@@ -209,7 +191,7 @@ namespace armarx::aron::xmltypereader
Reader anotherReader;
anotherReader.parseFile(resolved_absolute_path);
- if (Data::HasAttribute(node, Data::AUTO_CODE_INCLUDE))
+ if (util::HasAttribute(node, constantes::AUTO_CODE_INCLUDE))
{
std::string codeinclude = simox::alg::replace_last(resolved_relative_path, ".xml", ".aron.generated.h");
this->codeIncludes.push_back("<" + codeinclude + ">");
@@ -218,42 +200,17 @@ namespace armarx::aron::xmltypereader
return resolved_absolute_path.string();
}
- typenavigator::ObjectNavigatorPtr Reader::readGenerateObject(const RapidXmlReaderNode& node) const
+ type::ObjectPtr Reader::readGenerateObject(const RapidXmlReaderNode& node)
{
- Data::EnforceTagName(node, Data::GENERATE_OBJECT_TAG);
- return typenavigator::ObjectNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+ util::EnforceTagName(node, constantes::OBJECT_TAG);
+ return type::Object::DynamicCastAndCheck(factory.create(node, Path()));
}
- typenavigator::IntEnumNavigatorPtr Reader::readGenerateIntEnum(const RapidXmlReaderNode& node) const
+ type::IntEnumPtr Reader::readGenerateIntEnum(const RapidXmlReaderNode& node)
{
- Data::EnforceTagName(node, Data::GENERATE_INT_ENUM_TAG);
- return typenavigator::IntEnumNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+ util::EnforceTagName(node, constantes::INT_ENUM_TAG);
+ return type::IntEnum::DynamicCastAndCheck(factory.create(node, Path()));
}
-
-
- std::optional<fs::path> Reader::resolveRelativePackagePath(const fs::path& path)
- {
- const std::string package = *path.begin();
- armarx::CMakePackageFinder finder(package);
- if (finder.packageFound())
- {
- for (const std::string& includePath : finder.getIncludePathList())
- {
- fs::path absPath = includePath / path;
- if (fs::is_regular_file(absPath))
- {
- // path is valid
- return absPath;
- }
- }
- return std::nullopt;
- }
- else
- {
- return std::nullopt;
- }
- }
-
}
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.h b/source/RobotAPI/libraries/aron/core/typereader/xml/Reader.h
similarity index 67%
rename from source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.h
rename to source/RobotAPI/libraries/aron/core/typereader/xml/Reader.h
index c44f7d629fff62d5fb284dfe28445f4f7c4b9f5d..cd048d4dca481083639bfa282072570f61ac8d5d 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.h
+++ b/source/RobotAPI/libraries/aron/core/typereader/xml/Reader.h
@@ -30,28 +30,28 @@
// Base Class
-#include <RobotAPI/libraries/aron/core/codegenerator/typeReader/Reader.h>
+#include <RobotAPI/libraries/aron/core/typereader/Reader.h>
// ArmarX
#include <SimoxUtility/xml.h>
#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
-#include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
-#include <RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h>
+#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
+#include <RobotAPI/libraries/aron/core/typereader/xml/Factory.h>
-namespace armarx::aron::xmltypereader
+namespace armarx::aron::typereader::xml
{
- class Reader;
- typedef std::shared_ptr<Reader> ReaderPtr;
-
+ /**
+ * @brief The Reader class. It reads a xml-file and returns a type object and codegeneration information (such as additional includes etc)
+ */
class Reader :
virtual public typereader::Reader<std::string>
{
public:
Reader() = default;
- virtual void parseFile(const std::string&) override;
- virtual void parseFile(const std::filesystem::path&) override;
+ void parseFile(const std::string&) override;
+ void parseFile(const std::filesystem::path&) override;
private:
void parse(const RapidXmlReaderPtr& node, const std::filesystem::path& filePath);
@@ -59,10 +59,8 @@ namespace armarx::aron::xmltypereader
std::string readCodeInclude(const RapidXmlReaderNode& node, const std::filesystem::path& filePath);
std::string readAronInclude(const RapidXmlReaderNode& node, const std::filesystem::path& filePath);
- typenavigator::ObjectNavigatorPtr readGenerateObject(const RapidXmlReaderNode& node) const;
- typenavigator::IntEnumNavigatorPtr readGenerateIntEnum(const RapidXmlReaderNode& node) const;
-
- std::optional<std::filesystem::path> resolveRelativePackagePath(const std::filesystem::path& path);
+ type::ObjectPtr readGenerateObject(const RapidXmlReaderNode& node);
+ type::IntEnumPtr readGenerateIntEnum(const RapidXmlReaderNode& node);
private:
ReaderFactory factory;
diff --git a/source/RobotAPI/statecharts/WeissHapticGroup/WeissHapticSensorTest.h b/source/RobotAPI/statecharts/WeissHapticGroup/WeissHapticSensorTest.h
index 209f76d76dd939b0d1277a42ee15fc398eff9fd2..bce94688c8fbc38b0699509decd56534a6075cbb 100644
--- a/source/RobotAPI/statecharts/WeissHapticGroup/WeissHapticSensorTest.h
+++ b/source/RobotAPI/statecharts/WeissHapticGroup/WeissHapticSensorTest.h
@@ -27,9 +27,8 @@
namespace armarx::WeissHapticGroup
{
- class WeissHapticSensorTest
- :
- public WeissHapticSensorTestGeneratedBase<WeissHapticSensorTest>
+ class WeissHapticSensorTest :
+ public WeissHapticSensorTestGeneratedBase<WeissHapticSensorTest>
{
public:
WeissHapticSensorTest(const XMLStateConstructorParams& stateData);