diff --git a/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt b/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
index ad1ddc3669b4672d4d9a2f9def8cb4643b8d6821..fcc6342d5c779174e6322ff0c45bd9ca610758c2 100644
--- a/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
@@ -10,11 +10,13 @@ set(LIBS
set(LIB_FILES
Converter.cpp
VectorConverter.cpp
+ DatatypeConverter.cpp
)
set(LIB_HEADERS
Converter.h
VectorConverter.h
+ DatatypeConverter.h
)
armarx_add_library("${LIB_NAME}" "${LIB_FILES}" "${LIB_HEADERS}" "${LIBS}")
diff --git a/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77743613df7297b67273debdbcb0c71c0d346dff
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp
@@ -0,0 +1,151 @@
+#include "DatatypeConverter.h"
+
+namespace armarx::aron::converter
+{
+ void DatatypeConverter::visitAronVariant(const type::ObjectPtr& el)
+ {
+ auto dict = aron::make_dict(el->getPath());
+ auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+ dict->addElement(typeMemberName, type);
+
+ for (const auto& [key, child] : el->getMemberTypes())
+ {
+ DatatypeConverter converter;
+ aron::type::visit(converter, child);
+
+ dict->addElement(key, converter.latest);
+ }
+
+ latest = dict;
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::DictPtr& el)
+ {
+ auto dict = aron::make_dict(el->getPath());
+ auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+ dict->addElement(typeMemberName, type);
+
+ auto acceptedType = el->getAcceptedType();
+ DatatypeConverter converter;
+ aron::type::visit(converter, acceptedType);
+ dict->addElement(acceptedTypeMemberName, converter.latest);
+
+ latest = dict;
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::ListPtr& el)
+ {
+ auto dict = aron::make_dict(el->getPath());
+ auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+ dict->addElement(typeMemberName, type);
+
+ auto acceptedType = el->getAcceptedType();
+ DatatypeConverter converter;
+ aron::type::visit(converter, acceptedType);
+ dict->addElement(acceptedTypeMemberName, converter.latest);
+
+ latest = dict;
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::PairPtr& el)
+ {
+ auto dict = aron::make_dict(el->getPath());
+ auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+ dict->addElement(typeMemberName, type);
+
+ auto acceptedType1 = el->getFirstAcceptedType();
+ DatatypeConverter converter1;
+ aron::type::visit(converter1, acceptedType1);
+ dict->addElement(firstAcceptedTypeMemberName, converter1.latest);
+
+ auto acceptedType2 = el->getSecondAcceptedType();
+ DatatypeConverter converter2;
+ aron::type::visit(converter2, acceptedType2);
+ dict->addElement(secondAcceptedTypeMemberName, converter2.latest);
+
+ latest = dict;
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::TuplePtr& el)
+ {
+ auto dict = aron::make_dict(el->getPath());
+ auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+ dict->addElement(typeMemberName, type);
+
+ int i = 0;
+ for (const auto& child : el->getAcceptedTypes())
+ {
+ DatatypeConverter converter;
+ aron::type::visit(converter, child);
+
+ dict->addElement(acceptedTypeMemberName + "_" + std::to_string(i++), converter.latest);
+ }
+
+ latest = dict;
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::MatrixPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::NDArrayPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::QuaternionPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::PointCloudPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::ImagePtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::IntEnumPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::IntPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::LongPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::FloatPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::DoublePtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::BoolPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::StringPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+
+ void DatatypeConverter::visitAronVariant(const type::AnyObjectPtr& el)
+ {
+ latest = aron::make_string(el->getFullName(), el->getPath());
+ }
+}
diff --git a/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..34201b359d763ac81901135b475fd875714ab05c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h
@@ -0,0 +1,62 @@
+/*
+ * 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 )
+ * @date 2023
+ * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
+ * GNU General Public License
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <vector>
+
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h>
+
+namespace armarx::aron::converter
+{
+ class DatatypeConverter :
+ public aron::type::ConstVariantVisitor
+ {
+ const std::string typeMemberName = "_aron_type";
+ const std::string acceptedTypeMemberName = "_aron_accepted_type";
+ const std::string firstAcceptedTypeMemberName = "_aron_first_accepted_type";
+ const std::string secondAcceptedTypeMemberName = "_aron_second_accepted_type";
+
+ void visitAronVariant(const type::ObjectPtr&) override;
+ void visitAronVariant(const type::DictPtr&) override;
+ void visitAronVariant(const type::ListPtr&) override;
+ void visitAronVariant(const type::PairPtr&) override;
+ void visitAronVariant(const type::TuplePtr&) override;
+ void visitAronVariant(const type::MatrixPtr&) override;
+ void visitAronVariant(const type::NDArrayPtr&) override;
+ void visitAronVariant(const type::QuaternionPtr&) override;
+ void visitAronVariant(const type::PointCloudPtr&) override;
+ void visitAronVariant(const type::ImagePtr&) override;
+ void visitAronVariant(const type::IntEnumPtr&) override;
+ void visitAronVariant(const type::IntPtr&) override;
+ void visitAronVariant(const type::LongPtr&) override;
+ void visitAronVariant(const type::FloatPtr&) override;
+ void visitAronVariant(const type::DoublePtr&) override;
+ void visitAronVariant(const type::BoolPtr&) override;
+ void visitAronVariant(const type::StringPtr&) override;
+ void visitAronVariant(const type::AnyObjectPtr&) override;
+
+ public:
+ aron::data::VariantPtr latest;
+ };
+}
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
index 482c762d1426fef9c589a5c49e1ef14689cb6dcd..edaeccf90a02ec918fdbc90733a8209616e0bc1b 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
@@ -80,6 +80,16 @@ namespace armarx::aron::type
return "armarx::aron::type::Dict<" + acceptedType->getFullName() + ">";
}
+ std::string Dict::GetFullNamePrefix()
+ {
+ return "armarx::aron::type::Dict";
+ }
+
+ std::string Dict::GetNamePrefix()
+ {
+ return "Dict";
+ }
+
VariantPtr Dict::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
index 4dfdd35e238b39b729d67c583ec9378fc19f5c0e..7ebbf72eaa7a7582d9b33157279b857c14756540 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
@@ -59,6 +59,9 @@ namespace armarx::aron::type
std::vector<VariantPtr> getChildren() const override;
size_t childrenSize() const override;
+ static std::string GetFullNamePrefix();
+ static std::string GetNamePrefix();
+
private:
// members
VariantPtr acceptedType;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
index 7ee464bc121f8059dcd075dc29752e32be9761d4..958596b7e60f201e565d7082d2e26c7107d7ce05 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
@@ -80,6 +80,16 @@ namespace armarx::aron::type
return "armarx::aron::type::List<" + acceptedType->getFullName() + ">";
}
+ std::string List::GetFullNamePrefix()
+ {
+ return "armarx::aron::type::List";
+ }
+
+ std::string List::GetNamePrefix()
+ {
+ return "List";
+ }
+
VariantPtr List::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/List.h b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
index 532146e010bf8217c4669649ee2da9771c0623ec..67db861e299cc4031f560fbaa6507b20f1f3fbc5 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
@@ -58,6 +58,9 @@ namespace armarx::aron::type
std::vector<VariantPtr> getChildren() const override;
size_t childrenSize() const override;
+ static std::string GetFullNamePrefix();
+ static std::string GetNamePrefix();
+
private:
// members
VariantPtr acceptedType;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
index 526cc9f053d5e7bbf1e96c5f38bbe1f49a52cfbe..4ff701603aacaebbfde78dcac172c37f5ba51ae1 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
@@ -266,6 +266,16 @@ namespace armarx::aron::type
return "armarx::aron::type::Object<" + this->aron->objectName + (extends ? (" : " + extends->getFullName()) : "") + ">";
}
+ std::string Object::GetFullNamePrefix()
+ {
+ return "armarx::aron::type::Object";
+ }
+
+ std::string Object::GetNamePrefix()
+ {
+ return "Object";
+ }
+
VariantPtr Object::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
index 9924c2cbd5e53a633122fa665b970cbc28bd6043..ccaf50b572c9551538e0fb12f13fbfc2412e8538 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
@@ -86,6 +86,9 @@ namespace armarx::aron::type
std::vector<VariantPtr> getChildren() const override;
size_t childrenSize() const override;
+ static std::string GetFullNamePrefix();
+ static std::string GetNamePrefix();
+
private:
// members
std::shared_ptr<Object> extends;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
index 40b3cac3beb89df0323e08ffc681bde47ff29881..c147bd3dd3ab17a66b9e0068e6d3e044c663e67d 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
@@ -115,6 +115,16 @@ namespace armarx::aron::type
return "armarx::aron::type::Pair<" + acceptedType1->getFullName() + ", " + acceptedType2->getFullName() + ">";
}
+ std::string Pair::GetFullNamePrefix()
+ {
+ return "armarx::aron::type::Pair";
+ }
+
+ std::string Pair::GetNamePrefix()
+ {
+ return "Pair";
+ }
+
VariantPtr Pair::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
index a63f6819406ce2b328e97a4026aeae21127d7b09..e8bb11cd6fa82d711d87b39cf50b1dcfbd6f71fd 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
@@ -62,6 +62,9 @@ namespace armarx::aron::type
std::vector<VariantPtr> getChildren() const override;
size_t childrenSize() const override;
+ static std::string GetFullNamePrefix();
+ static std::string GetNamePrefix();
+
private:
// members
VariantPtr acceptedType1;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
index 51d45e3975bb162460fd06893e91f388ac52b9f1..cdcd605f2d475d4e8e83ab1d25a25914cc32e99a 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
@@ -112,6 +112,16 @@ namespace armarx::aron::type
return "armarx::aron::type::Tuple<" + simox::alg::to_string(names, ", ") + ">";
}
+ std::string Tuple::GetFullNamePrefix()
+ {
+ return "armarx::aron::type::Tuple";
+ }
+
+ std::string Tuple::GetNamePrefix()
+ {
+ return "Tuple";
+ }
+
VariantPtr Tuple::navigateAbsolute(const Path& path) const
{
if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
index 3281584c15d6b4bb3e50c83ce598634a2bbec324..070bed6264c8a2d9c19751d1b7866794e6e3bfb8 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
@@ -60,6 +60,9 @@ namespace armarx::aron::type
std::vector<VariantPtr> getChildren() const override;
size_t childrenSize() const override;
+ static std::string GetFullNamePrefix();
+ static std::string GetNamePrefix();
+
private:
std::vector<VariantPtr> acceptedTypes;
};
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
index ce0d34761f476da47b41db3afc6af464e7ac3146..a15811e6330d35b4d879202bf45859d5cc0e95ff 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
@@ -31,5 +31,7 @@ namespace armarx::aron::type
using StringPtr = std::shared_ptr<class String>;
using BoolPtr = std::shared_ptr<class Bool>;
+ using AnyObjectPtr = std::shared_ptr<class AnyObject>;
+
}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
index a2f46088a7b0f2261f67fac9931597cd97934f2b..0a132de3166df5d582652f07295fa084ecc05c9b 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
@@ -151,9 +151,6 @@ namespace armarx::aron::type
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&) {};
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
index d2b1c19a07e2b04fbf1e547d1cc39859793c90cc..72e02863e6ca67aea5be0b20ed9999a091893292 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
@@ -147,6 +147,12 @@ namespace armarx::aron::type
visitAronVariant(aron);
}
+ void ConstVariantVisitor::visitAnyObject(Input& i)
+ {
+ auto aron = type::AnyObject::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
void ConstVariantVisitor::visitAronVariant(const type::ObjectPtr&) {}
void ConstVariantVisitor::visitAronVariant(const type::DictPtr&) {}
void ConstVariantVisitor::visitAronVariant(const type::PairPtr&) {}
@@ -164,6 +170,7 @@ namespace armarx::aron::type
void ConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
void ConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
void ConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+ void ConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
/****************************************************************************
* RecursiveVariantVisitor
@@ -227,4 +234,166 @@ namespace armarx::aron::type
{
return GetTupleAcceptedTypes(t);
}
+
+ void RecursiveConstVariantVisitor::visitObjectOnEnter(Input& i)
+ {
+ auto aron = type::Object::DynamicCastAndCheck(i);
+ visitAronVariantEnter(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitObjectOnExit(Input& i)
+ {
+ auto aron = type::Object::DynamicCastAndCheck(i);
+ visitAronVariantExit(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitDictOnEnter(Input& i)
+ {
+ auto aron = type::Dict::DynamicCastAndCheck(i);
+ visitAronVariantEnter(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitDictOnExit(Input& i)
+ {
+ auto aron = type::Dict::DynamicCastAndCheck(i);
+ visitAronVariantExit(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitPairOnEnter(Input& i)
+ {
+ auto aron = type::Pair::DynamicCastAndCheck(i);
+ visitAronVariantEnter(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitPairOnExit(Input& i)
+ {
+ auto aron = type::Pair::DynamicCastAndCheck(i);
+ visitAronVariantExit(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitTupleOnEnter(Input& i)
+ {
+ auto aron = type::Tuple::DynamicCastAndCheck(i);
+ visitAronVariantEnter(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitTupleOnExit(Input& i)
+ {
+ auto aron = type::Tuple::DynamicCastAndCheck(i);
+ visitAronVariantExit(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitListOnEnter(Input& i)
+ {
+ auto aron = type::List::DynamicCastAndCheck(i);
+ visitAronVariantEnter(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitListOnExit(Input& i)
+ {
+ auto aron = type::List::DynamicCastAndCheck(i);
+ visitAronVariantExit(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitMatrix(Input& i)
+ {
+ auto aron = type::Matrix::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitNDArray(Input& i)
+ {
+ auto aron = type::NDArray::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitQuaternion(Input & i)
+ {
+ auto aron = type::Quaternion::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitImage(Input& i)
+ {
+ auto aron = type::Image::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitPointCloud(Input& i)
+ {
+ auto aron = type::PointCloud::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitIntEnum(Input& i)
+ {
+ auto aron = type::IntEnum::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitInt(Input& i)
+ {
+ auto aron = type::Int::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitLong(Input& i)
+ {
+ auto aron = type::Long::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitFloat(Input& i)
+ {
+ auto aron = type::Float::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitDouble(Input& i)
+ {
+ auto aron = type::Double::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitBool(Input& i)
+ {
+ auto aron = type::Bool::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitString(Input& i)
+ {
+ auto aron = type::String::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitAnyObject(Input& i)
+ {
+ auto aron = type::AnyObject::DynamicCastAndCheck(i);
+ visitAronVariant(aron);
+ }
+
+ void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ObjectPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ObjectPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::DictPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantExit(const type::DictPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::PairPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantExit(const type::PairPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::TuplePtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantExit(const type::TuplePtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ListPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ListPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::NDArrayPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::MatrixPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::QuaternionPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::ImagePtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::PointCloudPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::IntEnumPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::IntPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::LongPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::FloatPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+ void RecursiveConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
}
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
index e7e87fa45974a37ded813f3bfc156417238e5a02..fccfae04aff6b10bca173d3b096001af51dd6782 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
@@ -60,6 +60,7 @@ namespace armarx::aron::type
void visitDouble(Input&) override;
void visitBool(Input&) override;
void visitString(Input&) override;
+ void visitAnyObject(Input&) override;
// Use these if you do not want to cast manually
virtual void visitAronVariant(const type::ObjectPtr&);
@@ -79,6 +80,7 @@ namespace armarx::aron::type
virtual void visitAronVariant(const type::DoublePtr&);
virtual void visitAronVariant(const type::BoolPtr&);
virtual void visitAronVariant(const type::StringPtr&);
+ virtual void visitAronVariant(const type::AnyObjectPtr&);
};
/**
@@ -98,6 +100,57 @@ namespace armarx::aron::type
static TupleElements GetTupleAcceptedTypes(Input& t);
TupleElements getTupleAcceptedTypes(Input& t) override;
+ void visitObjectOnEnter(Input&) override;
+ void visitObjectOnExit(Input&) override;
+ void visitDictOnEnter(Input&) override;
+ void visitDictOnExit(Input&) override;
+ void visitPairOnEnter(Input&) override;
+ void visitPairOnExit(Input&) override;
+ void visitTupleOnEnter(Input&) override;
+ void visitTupleOnExit(Input&) override;
+ void visitListOnEnter(Input&) override;
+ void visitListOnExit(Input&) override;
+
+ void visitMatrix(Input&) override;
+ void visitNDArray(Input&) override;
+ void visitQuaternion(Input&) override;
+ void visitImage(Input&) override;
+ void visitPointCloud(Input&) override;
+ void visitIntEnum(Input&) override;
+ void visitInt(Input&) override;
+ void visitLong(Input&) override;
+ void visitFloat(Input&) override;
+ void visitDouble(Input&) override;
+ void visitBool(Input&) override;
+ void visitString(Input&) override;
+ void visitAnyObject(Input&) override;
+
+
+ // Use these if you do not want to cast manually
+ virtual void visitAronVariantEnter(const type::ObjectPtr&);
+ virtual void visitAronVariantExit(const type::ObjectPtr&);
+ virtual void visitAronVariantEnter(const type::DictPtr&);
+ virtual void visitAronVariantExit(const type::DictPtr&);
+ virtual void visitAronVariantEnter(const type::ListPtr&);
+ virtual void visitAronVariantExit(const type::ListPtr&);
+ virtual void visitAronVariantEnter(const type::PairPtr&);
+ virtual void visitAronVariantExit(const type::PairPtr&);
+ virtual void visitAronVariantEnter(const type::TuplePtr&);
+ virtual void visitAronVariantExit(const type::TuplePtr&);
+ virtual void visitAronVariant(const type::MatrixPtr&);
+ virtual void visitAronVariant(const type::NDArrayPtr&);
+ virtual void visitAronVariant(const type::QuaternionPtr&);
+ virtual void visitAronVariant(const type::PointCloudPtr&);
+ virtual void visitAronVariant(const type::ImagePtr&);
+ virtual void visitAronVariant(const type::IntEnumPtr&);
+ virtual void visitAronVariant(const type::IntPtr&);
+ virtual void visitAronVariant(const type::LongPtr&);
+ virtual void visitAronVariant(const type::FloatPtr&);
+ virtual void visitAronVariant(const type::DoublePtr&);
+ virtual void visitAronVariant(const type::BoolPtr&);
+ virtual void visitAronVariant(const type::StringPtr&);
+ virtual void visitAronVariant(const type::AnyObjectPtr&);
+
virtual ~RecursiveConstVariantVisitor() = default;
};
}