source/RobotAPI/libraries/armem_robot_state/client/common/RobotWriter.cpp

@@ -85,7 +85,7 @@ namespace armarx::armem::robot_state
         toAron(aronDescription, description);
 
         update.instancesData = {aronDescription.toAron()};
-        update.timeCreated = timestamp;
+        update.referencedTime = timestamp;
 
         ARMARX_DEBUG << "Committing " << update << " at time " << timestamp;
         armem::EntityUpdateResult updateResult = memoryWriter.commit(update);
@@ -129,7 +129,7 @@ namespace armarx::armem::robot_state
         }
 
         update.instancesData = {aronTransform.toAron()};
-        update.timeCreated = timestamp;
+        update.referencedTime = timestamp;
 
         ARMARX_DEBUG << "Committing " << update << " at time " << timestamp;
         armem::EntityUpdateResult updateResult = memoryWriter.commit(update);
@@ -163,7 +163,7 @@ namespace armarx::armem::robot_state
         aronProprioception.joints.position = jointMap;
 
         update.instancesData = {aronProprioception.toAron()};
-        update.timeCreated = timestamp;
+        update.referencedTime = timestamp;
 
         ARMARX_DEBUG << "Committing " << update << " at time " << timestamp;
         armem::EntityUpdateResult updateResult = memoryWriter.commit(update);

source/RobotAPI/libraries/armem_robot_state/client/localization/TransformWriter.cpp

@@ -98,7 +98,7 @@ namespace armarx::armem::client::robot_state::localization
 
         armem::EntityUpdate update;
         update.entityID = entityID;
-        update.timeCreated = timestamp;
+        update.referencedTime = timestamp;
 
         arondto::Transform aronTransform;
         toAron(aronTransform, transform);

source/RobotAPI/libraries/armem_robot_state/server/description/Segment.cpp

@@ -58,7 +58,7 @@ namespace armarx::armem::server::robot_state::description
 
         EntityUpdate update;
         update.entityID = providerID.withEntityName("description");
-        update.timeArrived = update.timeCreated = update.timeSent = now;
+        update.arrivedTime = update.referencedTime = update.sentTime = now;
 
         arondto::RobotDescription dto;
         robot::toAron(dto, robotDescription);

source/RobotAPI/libraries/armem_robot_state/server/localization/Segment.cpp

@@ -187,7 +187,7 @@ namespace armarx::armem::server::robot_state::localization
 
         EntityUpdate update;
         update.entityID = providerID.withEntityName(transform.header.parentFrame + "," + transform.header.frame);
-        update.timeArrived = update.timeCreated = update.timeSent = timestamp;
+        update.arrivedTime = update.referencedTime = update.sentTime = timestamp;
 
         arondto::Transform aronTransform;
         toAron(aronTransform, transform);

source/RobotAPI/libraries/armem_robot_state/server/proprioception/RobotStateWriter.cpp

@@ -159,7 +159,7 @@ namespace armarx::armem::server::robot_state::proprioception
             up.entityID = properties.robotUnitProviderID.withEntityName(
                 properties.robotUnitProviderID.providerSegmentName);
             up.entityID.coreSegmentName =::armarx::armem::robot_state::constants::proprioceptionCoreSegment;
-            up.timeCreated = data.timestamp;
+            up.referencedTime = data.timestamp;
             up.instancesData = {data.proprioception};
         }
 
@@ -169,7 +169,7 @@ namespace armarx::armem::server::robot_state::proprioception
             up.entityID = properties.robotUnitProviderID.withEntityName(
                 properties.robotUnitProviderID.providerSegmentName);
             up.entityID.coreSegmentName = ::armarx::armem::robot_state::constants::exteroceptionCoreSegment;
-            up.timeCreated = data.timestamp;
+            up.referencedTime = data.timestamp;
             up.instancesData = {data.exteroception};
         }
 

source/RobotAPI/libraries/armem_skills/CMakeLists.txt

@@ -13,6 +13,7 @@ armarx_add_library(
         RobotAPI::armem_server
         RobotAPI::skills
         aronjsonconverter
+        aroncommonconverter
     SOURCES  
         ./aron_conversions.cpp
 

source/RobotAPI/libraries/armem_skills/aron/Skill.xml

@@ -31,11 +31,11 @@ The memory should look like the following:
             </ObjectChild>
 
             <ObjectChild key='timeoutMs'>
-                <long />
+                <int64 />
             </ObjectChild>
 
             <ObjectChild key='acceptedType'>
-                <string /> <!-- TODO REPLACE! -->
+                <AnyObject shared_ptr="1" />
             </ObjectChild>
 
         </Object>

source/RobotAPI/libraries/armem_skills/server/segment/ExecutableSkillLibrarySegment.cpp

@@ -4,6 +4,7 @@
 #include <SimoxUtility/algorithm/string.h>
 
 #include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+#include <RobotAPI/libraries/aron/converter/common/DatatypeConverter.h>
 
 #include <RobotAPI/libraries/armem_skills/aron/Skill.aron.generated.h>
 
@@ -43,13 +44,19 @@ namespace armarx::skills::segment
             if (desc.acceptedType)
             {
                 auto t = aron::type::Object::FromAronObjectDTO(desc.acceptedType);
-                skillDescription.acceptedType = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(t).dump(2);
+
+                aron::converter::DatatypeConverter c;
+                aron::type::visit(c, t);
+
+                skillDescription.acceptedType = aron::data::Dict::DynamicCastAndCheck(c.latest);
             }
 
             armem::Commit commit;
             auto& entityUpdate = commit.add();
             entityUpdate.confidence = 1.0;
-            entityUpdate.timeCreated = armem::Time::Now();
+            entityUpdate.referencedTime = armem::Time::Now();
+            entityUpdate.sentTime = armem::Time::Now();
+            entityUpdate.arrivedTime = armem::Time::Now();
             entityUpdate.instancesData = {skillDescription.toAron()};
             entityUpdate.entityID = provId.withEntityName(skillDescription.skillName);
 

source/RobotAPI/libraries/armem_skills/server/segment/SkillEventSegment.cpp

@@ -54,7 +54,7 @@ namespace armarx::skills::segment
         armem::Commit comm;
         auto& entityUpdate = comm.add();
         entityUpdate.confidence = 1.0;
-        entityUpdate.timeCreated = armem::Time::Now();
+        entityUpdate.referencedTime = armem::Time::Now();
         entityUpdate.instancesData = { aron };
         entityUpdate.entityID = commitId;
 

source/RobotAPI/libraries/armem_skills/server/segment/SkillExecutionRequestSegment.cpp

@@ -66,7 +66,7 @@ namespace armarx::skills::segment
             entityUpdate.entityID = skillExecutionMemID;
             entityUpdate.instancesData = { aron };
             entityUpdate.confidence = 1.0;
-            entityUpdate.timeCreated = armem::Time::Now();
+            entityUpdate.referencedTime = armem::Time::Now();
         }
 
         {
@@ -79,7 +79,7 @@ namespace armarx::skills::segment
             entityUpdate.entityID = skillExecutionMemID;
             entityUpdate.instancesData = { aron };
             entityUpdate.confidence = 1.0;
-            entityUpdate.timeCreated = armem::Time::Now();
+            entityUpdate.referencedTime = armem::Time::Now();
         }
 
 

source/RobotAPI/libraries/armem_skills/server/segment/StatechartListenerSegment.cpp

@@ -31,7 +31,7 @@ namespace armarx::skills::segment
         armem::EntityUpdate update;
         update.entityID = segmentPtr->id().withEntityName(entityName);
 
-        update.timeCreated = transitionTime;
+        update.referencedTime = transitionTime;
         skills::arondto::Statechart::Transition data;
         armem::toAron(data, t);
         update.instancesData.push_back(data.toAron());

source/RobotAPI/libraries/armem_system_state/server/CPUSegment.cpp

@@ -63,7 +63,7 @@ namespace armarx::armem::server::systemstate::segment
         EntityUpdate update;
         update.entityID = providerId.withEntityName("CurrentCpuLoad");
         update.confidence = 1.0;
-        update.timeCreated = armem::Time::Now();
+        update.referencedTime = armem::Time::Now();
         update.instancesData = { data };
 
         segmentPtr->update(update);

source/RobotAPI/libraries/armem_system_state/server/RAMSegment.cpp

@@ -54,7 +54,7 @@ namespace armarx::armem::server::systemstate::segment
         EntityUpdate update;
         update.entityID = providerId.withEntityName("CurrentMemoryLoad");
         update.confidence = 1.0;
-        update.timeCreated = armem::Time::Now();
+        update.referencedTime = armem::Time::Now();
         update.instancesData = { data };
 
         segmentPtr->update(update);

source/RobotAPI/libraries/armem_vision/client/laser_scanner_features/Writer.cpp

@@ -91,7 +91,7 @@ namespace armarx::armem::vision::laser_scanner_features::client
         ARMARX_TRACE;
 
         update.instancesData = {dto.toAron()};
-        update.timeCreated = timestamp;
+        update.referencedTime = timestamp;
 
         ARMARX_DEBUG << "Committing " << update << " at time " << timestamp;
 

source/RobotAPI/libraries/armem_vision/client/occupancy_grid/Writer.cpp

@@ -41,7 +41,7 @@ namespace armarx::armem::vision::occupancy_grid::client
         dict->addElement("grid", toAron(grid.grid));
 
         update.instancesData = {dict};
-        update.timeCreated   = iceTimestamp;
+        update.referencedTime   = iceTimestamp;
 
         ARMARX_DEBUG << "Committing " << update << " at time " << iceTimestamp;
         armem::EntityUpdateResult updateResult = memoryWriter().commit(update);

source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/CodeWriter.h

@@ -76,10 +76,18 @@ namespace armarx::aron::codegenerator
         std::vector<MetaEnumPtr> typeEnums;
 
         std::string producerName;
-        std::vector<codegenerator::WriterInfo> dataWriters;
-        std::vector<codegenerator::ReaderInfo> dataReaders;
-        std::vector<codegenerator::StaticReaderInfo> staticDataReaders;
-        std::vector<codegenerator::WriterInfo> initialTypeWriters;
+        std::vector<codegenerator::WriterInfo> dictDataWriters;
+        std::vector<codegenerator::WriterInfo> intEnumDataWriters;
+
+        std::vector<codegenerator::ReaderInfo> dictDataReaders;
+        std::vector<codegenerator::ReaderInfo> intEnumDataReaders;
+
+        std::vector<codegenerator::StaticReaderInfo> staticDictDataReaders;
+        std::vector<codegenerator::StaticReaderInfo> staticIntEnumDataReaders;
+
+        std::vector<codegenerator::WriterInfo> initialDictTypeWriters;
+        std::vector<codegenerator::WriterInfo> initialIntEnumTypeWriters;
+
         std::vector<std::string> additionalIncludes;
     };
 }

source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/Writer.cpp

@@ -80,90 +80,182 @@ namespace armarx::aron::codegenerator::cpp
 
     void Writer::addSpecificWriterMethods()
     {
-        // The toAron Serializer is visible by default
+        // DictData stuff
         {
-            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);
-        }
-
-        {
-            codegenerator::WriterInfo toAronDTO;
-            toAronDTO.methodName = "toAronDTO";
-            toAronDTO.returnType = "armarx::aron::data::dto::DictPtr";
-            toAronDTO.writerClassType = "armarx::aron::data::writer::VariantWriter";
-            toAronDTO.include = "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
-            toAronDTO.enforceConversion = "armarx::aron::data::Dict::DynamicCastAndCheck";
-            toAronDTO.enforceMemberAccess = "->toAronDictDTO()";
-            dataWriters.push_back(toAronDTO);
-        }
-
-        {
-            // 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);
+            {
+                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";
+                toAron.override = true;
+                dictDataWriters.push_back(toAron);
+            }
+            {
+                codegenerator::WriterInfo toAronDTO;
+                toAronDTO.methodName = "toAronDTO";
+                toAronDTO.returnType = "armarx::aron::data::dto::DictPtr";
+                toAronDTO.writerClassType = "armarx::aron::data::writer::VariantWriter";
+                toAronDTO.include =
+                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
+                toAronDTO.enforceConversion = "armarx::aron::data::Dict::DynamicCastAndCheck";
+                toAronDTO.enforceMemberAccess = "->toAronDictDTO()";
+                toAronDTO.override = true;
+                dictDataWriters.push_back(toAronDTO);
+            }
+            {
+                // 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";
+                initialDictTypeWriters.push_back(ToAronType);
+            }
+            {
+                // The toAron Serializer is visible by default
+                codegenerator::WriterInfo ToAronTypeDTO;
+                ToAronTypeDTO.methodName = "ToAronTypeDTO";
+                ToAronTypeDTO.returnType = "armarx::aron::type::dto::AronObjectPtr";
+                ToAronTypeDTO.writerClassType = "armarx::aron::type::writer::VariantWriter";
+                ToAronTypeDTO.include =
+                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
+                ToAronTypeDTO.enforceConversion = "armarx::aron::type::Object::DynamicCastAndCheck";
+                ToAronTypeDTO.enforceMemberAccess = "->toAronObjectDTO()";
+                initialDictTypeWriters.push_back(ToAronTypeDTO);
+            }
         }
 
+        // IntEnum stuff
         {
-            // The toAron Serializer is visible by default
-            codegenerator::WriterInfo ToAronTypeDTO;
-            ToAronTypeDTO.methodName = "ToAronTypeDTO";
-            ToAronTypeDTO.returnType = "armarx::aron::type::dto::AronObjectPtr";
-            ToAronTypeDTO.writerClassType = "armarx::aron::type::writer::VariantWriter";
-            ToAronTypeDTO.include = "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
-            ToAronTypeDTO.enforceConversion = "armarx::aron::type::Object::DynamicCastAndCheck";
-            ToAronTypeDTO.enforceMemberAccess = "->toAronObjectDTO()";
-            initialTypeWriters.push_back(ToAronTypeDTO);
+            {
+                codegenerator::WriterInfo toAron;
+                toAron.methodName = "toAron";
+                toAron.returnType = "armarx::aron::data::IntPtr";
+                toAron.writerClassType = "armarx::aron::data::writer::VariantWriter";
+                toAron.include =
+                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
+                toAron.enforceConversion = "armarx::aron::data::Int::DynamicCastAndCheck";
+                toAron.override = true;
+                intEnumDataWriters.push_back(toAron);
+            }
+            {
+                codegenerator::WriterInfo toAronDTO;
+                toAronDTO.methodName = "toAronDTO";
+                toAronDTO.returnType = "armarx::aron::data::dto::AronIntPtr";
+                toAronDTO.writerClassType = "armarx::aron::data::writer::VariantWriter";
+                toAronDTO.include =
+                    "<RobotAPI/libraries/aron/core/data/rw/writer/variant/VariantWriter.h>";
+                toAronDTO.enforceConversion = "armarx::aron::data::Int::DynamicCastAndCheck";
+                toAronDTO.enforceMemberAccess = "->toAronIntDTO()";
+                toAronDTO.override = true;
+                intEnumDataWriters.push_back(toAronDTO);
+            }
+            {
+                // The toAron Serializer is visible by default
+                codegenerator::WriterInfo ToAronType;
+                ToAronType.methodName = "ToAronType";
+                ToAronType.returnType = "armarx::aron::type::IntEnumPtr";
+                ToAronType.writerClassType = "armarx::aron::type::writer::VariantWriter";
+                ToAronType.include =
+                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
+                ToAronType.enforceConversion = "armarx::aron::type::IntEnum::DynamicCastAndCheck";
+                initialIntEnumTypeWriters.push_back(ToAronType);
+            }
+            {
+                // The toAron Serializer is visible by default
+                codegenerator::WriterInfo ToAronTypeDTO;
+                ToAronTypeDTO.methodName = "ToAronTypeDTO";
+                ToAronTypeDTO.returnType = "armarx::aron::type::dto::IntEnumPtr";
+                ToAronTypeDTO.writerClassType = "armarx::aron::type::writer::VariantWriter";
+                ToAronTypeDTO.include =
+                    "<RobotAPI/libraries/aron/core/type/rw/writer/variant/VariantWriter.h>";
+                ToAronTypeDTO.enforceConversion = "armarx::aron::type::IntEnum::DynamicCastAndCheck";
+                ToAronTypeDTO.enforceMemberAccess = "->toIntEnumDTO()";
+                initialIntEnumTypeWriters.push_back(ToAronTypeDTO);
+            }
         }
     }
 
     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);
-        }
-
+        // Dict stuff
         {
-            codegenerator::StaticReaderInfo fromAronDTO;
-            fromAronDTO.methodName = "FromAron";
-            fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
-            fromAronDTO.returnType = OWN_TYPE_NAME;
-            staticDataReaders.push_back(fromAronDTO);
-        }
-
-
-        // 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);
+            {
+                codegenerator::StaticReaderInfo fromAron;
+                fromAron.methodName = "FromAron";
+                fromAron.argumentType = "armarx::aron::data::DictPtr";
+                fromAron.returnType = OWN_TYPE_NAME;
+                staticDictDataReaders.push_back(fromAron);
+            }
+            {
+                codegenerator::StaticReaderInfo fromAronDTO;
+                fromAronDTO.methodName = "FromAron";
+                fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
+                fromAronDTO.returnType = OWN_TYPE_NAME;
+                staticDictDataReaders.push_back(fromAronDTO);
+            }
+            {
+                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>";
+                fromAron.override = true;
+                dictDataReaders.push_back(fromAron);
+            }
+            {
+                codegenerator::ReaderInfo fromAronDTO;
+                fromAronDTO.methodName = "fromAron";
+                fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
+                fromAronDTO.readerClassType = "armarx::aron::data::reader::VariantReader";
+                fromAronDTO.include = "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
+                fromAronDTO.enforceConversion = "std::make_shared<armarx::aron::data::Dict>";
+                fromAronDTO.override = true;
+                dictDataReaders.push_back(fromAronDTO);
+            }
         }
 
+        // IntEnum stuff
         {
-            codegenerator::ReaderInfo fromAronDTO;
-            fromAronDTO.methodName = "fromAron";
-            fromAronDTO.argumentType = "armarx::aron::data::dto::DictPtr";
-            fromAronDTO.readerClassType = "armarx::aron::data::reader::VariantReader";
-            fromAronDTO.include = "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
-            fromAronDTO.enforceConversion = "std::make_shared<armarx::aron::data::Dict>";
-            dataReaders.push_back(fromAronDTO);
+            {
+                codegenerator::StaticReaderInfo fromAron;
+                fromAron.methodName = "FromAron";
+                fromAron.argumentType = "armarx::aron::data::IntPtr";
+                fromAron.returnType = OWN_TYPE_NAME;
+                staticIntEnumDataReaders.push_back(fromAron);
+            }
+            {
+                codegenerator::StaticReaderInfo fromAronDTO;
+                fromAronDTO.methodName = "FromAron";
+                fromAronDTO.argumentType = "armarx::aron::data::dto::AronIntPtr";
+                fromAronDTO.returnType = OWN_TYPE_NAME;
+                staticIntEnumDataReaders.push_back(fromAronDTO);
+            }
+            {
+                codegenerator::ReaderInfo fromAron;
+                fromAron.methodName = "fromAron";
+                fromAron.argumentType = "armarx::aron::data::IntPtr";
+                fromAron.readerClassType = "armarx::aron::data::reader::VariantReader";
+                fromAron.include = "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
+                fromAron.override = true;
+                intEnumDataReaders.push_back(fromAron);
+            }
+            {
+                codegenerator::ReaderInfo fromAronDTO;
+                fromAronDTO.methodName = "fromAron";
+                fromAronDTO.argumentType = "armarx::aron::data::dto::AronIntPtr";
+                fromAronDTO.readerClassType = "armarx::aron::data::reader::VariantReader";
+                fromAronDTO.include =
+                    "<RobotAPI/libraries/aron/core/data/rw/reader/variant/VariantReader.h>";
+                fromAronDTO.enforceConversion = "std::make_shared<armarx::aron::data::Int>";
+                fromAronDTO.override = true;
+                intEnumDataReaders.push_back(fromAronDTO);
+            }
         }
     }
 
@@ -190,7 +282,7 @@ namespace armarx::aron::codegenerator::cpp
                 std::vector<std::string> tmpl_requires;
                 for (auto& t : type->getTemplates())
                 {
-                    tmpl_requires.push_back("armarx::aron::cpp::isAronGeneratedClass<" + t + ">");
+                    tmpl_requires.push_back("armarx::aron::cpp::isAronGeneratedObject<" + t + ">");
                     tmpl.push_back("class " + t);
                 }
                 std::string templateDef = "template <" + simox::alg::join(tmpl, ", ") + ">";
@@ -206,11 +298,11 @@ namespace armarx::aron::codegenerator::cpp
             }
             else
             {
-                c->addInherit("public armarx::aron::cpp::AronGeneratedClass");
+                c->addInherit("public armarx::aron::cpp::AronGeneratedObject<" + generator.getFullClassCppTypename() + ">");
             }
 
             // Writermethods
-            for (codegenerator::WriterInfo info : dataWriters)
+            for (codegenerator::WriterInfo info : dictDataWriters)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -221,13 +313,14 @@ namespace armarx::aron::codegenerator::cpp
                 {
                     c->addInclude(info.include);
                 }
+
                 CppMethodPtr convert = generator.toSpecializedDataWriterMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Add methods to set the member variables
             // also resolve the original class name if the return type is set to special
-            for (codegenerator::StaticReaderInfo info : staticDataReaders)
+            for (codegenerator::StaticReaderInfo info : staticDictDataReaders)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -239,11 +332,11 @@ namespace armarx::aron::codegenerator::cpp
                 }
 
                 CppMethodPtr convert = generator.toSpecializedStaticDataReaderMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Add methods to set the member variables
-            for (codegenerator::ReaderInfo info : dataReaders)
+            for (codegenerator::ReaderInfo info : dictDataReaders)
             {
                 if (info.argumentType == OWN_TYPE_NAME)
                 {
@@ -254,12 +347,13 @@ namespace armarx::aron::codegenerator::cpp
                 {
                     c->addInclude(info.include);
                 }
+
                 CppMethodPtr convert = generator.toSpecializedDataReaderMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Typewritermethods
-            for (codegenerator::WriterInfo info : initialTypeWriters)
+            for (codegenerator::WriterInfo info : initialDictTypeWriters)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -271,7 +365,7 @@ namespace armarx::aron::codegenerator::cpp
                     c->addInclude(info.include);
                 }
                 CppMethodPtr convert = generator.toSpecializedTypeWriterMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             typeClasses.push_back(c);
@@ -293,33 +387,35 @@ namespace armarx::aron::codegenerator::cpp
 
             // Generate aron wrapper class and add to classes
             CppClassPtr c = setupBasicCppClass(publicGenerateIntEnumType, generator);
+            c->addInclude("<RobotAPI/libraries/aron/core/data/variant/primitive/Int.h>");
+
             setupMemberFields(c, publicGenerateIntEnumType.doc_values, generator);
 
-            c->addInherit("public armarx::aron::cpp::AronGeneratedClass");
+            c->addInherit("public armarx::aron::cpp::AronGeneratedIntEnum<" + generator.getFullClassCppTypename() + ">");
 
             // ctor
             c->addCtor(generator.toEnumCtor(c->getName()));
 
             CppMethodPtr toString = generator.toToStringMethod();
-            c->addMethod(toString);
+            c->addPublicMethod(toString);
 
             CppMethodPtr fromString = generator.toFromStringMethod();
-            c->addMethod(fromString);
+            c->addPublicMethod(fromString);
 
             CppMethodPtr intConversion = generator.toIntMethod();
-            c->addMethod(intConversion);
+            c->addPublicMethod(intConversion);
 
             CppMethodPtr enumAssignment = generator.toEnumAssignmentMethod();
-            c->addMethod(enumAssignment);
+            c->addPublicMethod(enumAssignment);
 
             CppMethodPtr enumAssignment2 = generator.toCopyAssignmentMethod();
-            c->addMethod(enumAssignment2);
+            c->addPublicMethod(enumAssignment2);
 
             CppMethodPtr enumAssignment3 = generator.toIntAssignmentMethod();
-            c->addMethod(enumAssignment3);
+            c->addPublicMethod(enumAssignment3);
 
             // Writermethods
-            for (codegenerator::WriterInfo info : dataWriters)
+            for (codegenerator::WriterInfo info : intEnumDataWriters)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -330,13 +426,14 @@ namespace armarx::aron::codegenerator::cpp
                 {
                     c->addInclude(info.include);
                 }
+
                 CppMethodPtr convert = generator.toSpecializedDataWriterMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Add methods to set the member variables
             // also resolve the original class name if the return type is set to special
-            for (codegenerator::StaticReaderInfo info : staticDataReaders)
+            for (codegenerator::StaticReaderInfo info : staticIntEnumDataReaders)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -348,11 +445,11 @@ namespace armarx::aron::codegenerator::cpp
                 }
 
                 CppMethodPtr convert = generator.toSpecializedStaticDataReaderMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Add methods to set the member variables
-            for (codegenerator::ReaderInfo info : dataReaders)
+            for (codegenerator::ReaderInfo info : intEnumDataReaders)
             {
                 if (info.argumentType == OWN_TYPE_NAME)
                 {
@@ -364,11 +461,11 @@ namespace armarx::aron::codegenerator::cpp
                     c->addInclude(info.include);
                 }
                 CppMethodPtr convert = generator.toSpecializedDataReaderMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             // Typewritermethods
-            for (codegenerator::WriterInfo info : initialTypeWriters)
+            for (codegenerator::WriterInfo info : initialIntEnumTypeWriters)
             {
                 if (info.returnType == OWN_TYPE_NAME)
                 {
@@ -380,7 +477,7 @@ namespace armarx::aron::codegenerator::cpp
                     c->addInclude(info.include);
                 }
                 CppMethodPtr convert = generator.toSpecializedTypeWriterMethod(info);
-                c->addMethod(convert);
+                c->addPublicMethod(convert);
             }
 
             typeClasses.push_back(c);
@@ -406,6 +503,8 @@ namespace armarx::aron::codegenerator::cpp
         CppEnumPtr e = std::make_shared<CppEnum>(namespaces, "Enum");
         auto enumFields = gen.toEnumFields();
 
+        ARMARX_CHECK(enumFields.size() > 0);
+
         for (const auto& field : enumFields)
         {
             e->addField(field);
@@ -441,7 +540,6 @@ namespace armarx::aron::codegenerator::cpp
         }
 
         c->addClassDoc(classDoc);
-        c->setPragmaOnceIncludeGuard(true);
 
         // add generator includes (e.g. coming from dto types)
         for (const auto& s : gen.getRequiredIncludes())
@@ -465,38 +563,40 @@ namespace armarx::aron::codegenerator::cpp
         c->addInclude("<RobotAPI/libraries/aron/core/aron_conversions.h>");
         c->addInclude("<RobotAPI/libraries/aron/core/rw.h>");
         c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedClass.h>");
+        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedObject.h>");
+        c->addInclude("<RobotAPI/libraries/aron/core/codegeneration/cpp/AronGeneratedIntEnum.h>");
 
         // ctor
         c->addCtor(gen.toCtor(c->getName()));
         c->addCtor(gen.toCopyCtor(c->getName()));
 
         // dtor
-        c->addMethod(gen.toDtor(c->getName()));
+        c->addPublicMethod(gen.toDtor(c->getName()));
 
         // Generic methods
         //std::cout << "Generate equals method" << std::endl;
         CppMethodPtr equals = gen.toEqualsMethod();
-        c->addMethod(equals);
+        c->addPublicMethod(equals);
 
         //std::cout << "Generate reset method" << std::endl;
         CppMethodPtr resetHard = gen.toResetHardMethod();
-        c->addMethod(resetHard);
+        c->addPublicMethod(resetHard);
 
         //std::cout << "Generate init method" << std::endl;
         CppMethodPtr resetSoft = gen.toResetSoftMethod();
-        c->addMethod(resetSoft);
+        c->addPublicMethod(resetSoft);
 
         //std::cout << "Generate writeInit method" << std::endl;
         CppMethodPtr writeType = gen.toWriteTypeMethod();
-        c->addMethod(writeType);
+        c->addPublicMethod(writeType);
 
         //std::cout << "Generate write method" << std::endl;
         CppMethodPtr write = gen.toWriteMethod();
-        c->addMethod(write);
+        c->addPublicMethod(write);
 
         //std::cout << "Generate read method" << std::endl;
         CppMethodPtr read = gen.toReadMethod();
-        c->addMethod(read);
+        c->addPublicMethod(read);
         return c;
     }
 

source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/Generator.cpp

@@ -317,7 +317,7 @@ namespace armarx::aron::codegenerator::cpp
         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()));
+        CppMethodPtr m = CppMethodPtr(new CppMethod(info.returnType + " " + info.methodName + "() const" + (info.override ? " override" : ""), doc.str()));
         m->addLine(info.writerClassType + " writer;");
         m->addLine("return " + info.enforceConversion + "(this->write(writer))" + info.enforceMemberAccess + ";");
 
@@ -331,7 +331,7 @@ namespace armarx::aron::codegenerator::cpp
         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()));
+        CppMethodPtr m = CppMethodPtr(new CppMethod("void " + info.methodName + "(const " + info.argumentType + "& input)" + (info.override ? " override" : ""), doc.str()));
         m->addLine(info.readerClassType + " reader;");
         m->addLine("this->read(reader, " + info.enforceConversion + "(input)" + info.enforceMemberAccess + ");");
 
@@ -395,9 +395,9 @@ namespace armarx::aron::codegenerator::cpp
         return {field};
     }
 
-    std::pair<std::vector<std::pair<std::string, std::string>>, bool> Generator::getCtorInitializers(const std::string&) const
+    std::pair<std::vector<std::pair<std::string, std::string>>, bool> Generator::getCtorInitializers(const std::string& name) const
     {
-        return {{}, false};
+        return {{{name, "{}"}}, false};
     }
 
     CppBlockPtr Generator::getCtorBlock(const std::string&) const
@@ -408,7 +408,7 @@ namespace armarx::aron::codegenerator::cpp
     std::pair<std::vector<std::pair<std::string, std::string>>, bool> Generator::getCopyCtorInitializers(const std::string& name) const
     {
         const auto& t = getType();
-        if (t.getMaybe() == type::Maybe::UNIQUE_PTR || t.getMaybe() == type::Maybe::RAW_PTR)
+        if (t.getMaybe() == type::Maybe::UNIQUE_PTR) // unique ptrs cant be copied
         {
             return {{{name, ARON_OTHER_ACCESSOR + "." + name + " ? " + resolveMaybeGenerator("*" + ARON_OTHER_ACCESSOR + "." + name) + " : nullptr"}}, true};
         }

source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp

@@ -55,6 +55,8 @@ namespace armarx::aron::codegenerator::cpp::generator
         // add legacy typedef
         fields.push_back(std::make_shared<CppField>("using", std::string(IMPL_ENUM), simox::alg::to_lower(className) + "_details::Enum", "Legacy typedef of enum"));
 
+        ARMARX_CHECK(type.getAcceptedValueMap().size() > 0);
+
         enum_to_name << "{" << std::endl;
         name_to_enum << "{" << std::endl;
         enum_to_value << "{" << std::endl;
@@ -81,7 +83,7 @@ namespace armarx::aron::codegenerator::cpp::generator
         fields.push_back(std::make_shared<CppField>("static inline const std::map<" + std::string(IMPL_ENUM) + ", int>", "EnumToValueMap", enum_to_value.str(), "Mapping enum values to a int value"));
         fields.push_back(std::make_shared<CppField>("static inline const std::map<int, " + std::string(IMPL_ENUM) + ">", "ValueToEnumMap", value_to_enum.str(), "Mapping int values to a enum"));
 
-        fields.push_back(std::make_shared<CppField>(std::string(IMPL_ENUM), "value", "", "The current value of the enum object"));
+        fields.push_back(std::make_shared<CppField>(std::string(IMPL_ENUM), "value", type.getAcceptedValueNames()[0], "The current value of the enum object"));
 
         return fields;
     }
@@ -162,11 +164,6 @@ namespace armarx::aron::codegenerator::cpp::generator
         return c;
     }*/
 
-    std::pair<std::vector<std::pair<std::string, std::string>>, bool> IntEnumClass::getCopyCtorInitializers(const std::string&) const
-    {
-        return {{{"value", ARON_OTHER_ACCESSOR + ".value"}}, false};
-    }
-
     CppCtorPtr IntEnumClass::toEnumCtor(const std::string& name) const
     {
         CppCtorPtr c = std::make_shared<CppCtor>(name + "(const " + std::string(IMPL_ENUM) + " e)");

source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h

@@ -43,8 +43,6 @@ namespace armarx::aron::codegenerator::cpp::generator
         // virtual implementations
         std::vector<CppFieldPtr> getPublicVariableDeclarations(const std::string&) const final;
 
-        std::pair<std::vector<std::pair<std::string, std::string>>, bool> getCopyCtorInitializers(const std::string&) const final;
-
         CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
         CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
         CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path&, std::string& variantAccessor) const final;