Factory.cpp

Go to the documentation of this file.

/*
 * 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 <ArmarXCore/core/time/DateTime.h>
 
#include <RobotAPI/libraries/aron/core/type/variant/All.h>
 
#include "Data.h"
 
namespace armarx::aron::typereader::xml
{
    void
    printDeprecationWarning(const std::string& warning)
    {
        auto v = armarx::aron::Version();
        auto v_str =
            std::to_string(v.MAJOR) + "." + std::to_string(v.MINOR) + "." + std::to_string(v.PATCH);
        std::cout
            << "\033[1;33m[**Aron v" + v_str + " deprecation warning**]: " << warning
            << "\nPlease note that a future version of aron might not support this anymore.\033[0m"
            << std::endl;
    }
 
    void
    printWarning(const std::string& warning)
    {
        std::cout << "\033[1;33m[**Aron warning**]: " << warning << "\033[0m" << std::endl;
    }
 
    type::VariantPtr
    ReaderFactory::create(const RapidXmlReaderNode& node, const Path& path)
    {
        static const std::map<std::string, type::Descriptor> String2Descriptor = {
            {constantes::LIST_TAG, type::Descriptor::LIST},
            {constantes::OBJECT_TAG, type::Descriptor::OBJECT},
            {constantes::TUPLE_TAG, type::Descriptor::TUPLE},
            {constantes::PAIR_TAG, type::Descriptor::PAIR},
            {constantes::DICT_TAG, type::Descriptor::DICT},
            {constantes::NDARRAY_TAG, type::Descriptor::NDARRAY},
            {constantes::MATRIX_TAG, type::Descriptor::MATRIX},
            {constantes::QUATERNION_TAG, type::Descriptor::QUATERNION},
            {constantes::POINT_CLOUD_TAG, type::Descriptor::POINTCLOUD},
            {constantes::IMAGE_TAG, type::Descriptor::IMAGE},
            {constantes::INT_ENUM_TAG, type::Descriptor::INT_ENUM},
            {constantes::INT_TAG, type::Descriptor::INT},
            {constantes::LONG_TAG, type::Descriptor::LONG},
            {constantes::FLOAT_TAG, type::Descriptor::FLOAT},
            {constantes::DOUBLE_TAG, type::Descriptor::DOUBLE},
            {constantes::STRING_TAG, type::Descriptor::STRING},
            {constantes::BOOL_TAG, type::Descriptor::BOOL},
            {constantes::ANY_OBJECT_TAG, type::Descriptor::ANY_OBJECT}};
 
        RapidXmlReaderNode nodeToUse = node;
 
        // check for replacement
        if (auto it = constantes::REPLACEMENTS.find(simox::alg::to_lower(nodeToUse.name()));
            it != constantes::REPLACEMENTS.end())
        {
            auto replacement = it->second;
            if (!replacement.deprecatedWarning.empty())
            {
                printDeprecationWarning(replacement.deprecatedWarning);
            }
 
            std::string tag = replacement.replacementTag;
            if (util::HasAttribute(nodeToUse, constantes::DEFAULT_ATTRIBUTE_NAME))
            {
                tag += " " + std::string(constantes::DEFAULT_ATTRIBUTE_NAME) + "=\"" +
                       util::GetAttribute(nodeToUse, constantes::DEFAULT_ATTRIBUTE_NAME) + "\"";
            }
 
            // We make the system believe there is another string in the xml
            RapidXmlReaderPtr reader = RapidXmlReader::FromXmlString("<" + tag + " />");
            nodeToUse = reader->getRoot();
        }
 
        auto it = String2Descriptor.find(simox::alg::to_lower(nodeToUse.name()));
        auto descriptor = (it == String2Descriptor.end() ? type::Descriptor::UNKNOWN : it->second);
 
        switch (descriptor)
        {
            case type::Descriptor::LIST:
                return createList(nodeToUse, path);
            case type::Descriptor::DICT:
                return createDict(nodeToUse, path);
            case type::Descriptor::OBJECT:
                return createObject(nodeToUse, path);
            case type::Descriptor::TUPLE:
                return createTuple(nodeToUse, path);
            case type::Descriptor::PAIR:
                return createPair(nodeToUse, path);
            case type::Descriptor::NDARRAY:
                return createNDArray(nodeToUse, path);
            case type::Descriptor::MATRIX:
                return createMatrix(nodeToUse, path);
            case type::Descriptor::QUATERNION:
                return createQuaternion(nodeToUse, path);
            case type::Descriptor::IMAGE:
                return createImage(nodeToUse, path);
            case type::Descriptor::POINTCLOUD:
                return createPointCloud(nodeToUse, path);
            case type::Descriptor::INT_ENUM:
                return createIntEnum(nodeToUse, path);
            case type::Descriptor::INT:
                return createInt(nodeToUse, path);
            case type::Descriptor::LONG:
                return createLong(nodeToUse, path);
            case type::Descriptor::FLOAT:
                return createFloat(nodeToUse, path);
            case type::Descriptor::DOUBLE:
                return createDouble(nodeToUse, path);
            case type::Descriptor::STRING:
                return createString(nodeToUse, path);
            case type::Descriptor::BOOL:
                return createBool(nodeToUse, path);
            case type::Descriptor::ANY_OBJECT:
                return createAnyObject(nodeToUse, path);
            case type::Descriptor::UNKNOWN:
                return findExistingObject(nodeToUse.name(), path);
        }
 
        throw aron::error::AronEOFException(__PRETTY_FUNCTION__);
    }
 
    type::VariantPtr
    ReaderFactory::findExistingObject(const std::string& name, const Path& path) const
    {
        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(), path);
            return v;
        }
 
        const auto public_obj_it = allGeneratedPublicObjects.find(name);
        if (public_obj_it != allGeneratedPublicObjects.end())
        {
            // copy the navigator and set instantiation template args
            auto v = type::Variant::FromAronDTO(
                *public_obj_it->second.correspondingType->toAronDTO(), path);
            return v;
        }
 
        const auto public_known_it = std::find(
            allPreviouslyKnownPublicTypes.begin(), allPreviouslyKnownPublicTypes.end(), name);
        if (public_known_it != allPreviouslyKnownPublicTypes.end())
        {
            // create an empty navigator
            auto v = std::make_shared<aron::type::Object>(path);
            v->setObjectName(*public_known_it);
            v->setTemplates({});
            v->setTemplateInstantiations({});
            v->setMemberTypes({});
            return v;
        }
 
        // only works during generation process (not for top-level). Used for templates.
        const auto private_known_it = std::find(
            allPreviouslyKnownPrivateTypes.begin(), allPreviouslyKnownPrivateTypes.end(), name);
        if (private_known_it != allPreviouslyKnownPrivateTypes.end())
        {
            // create an empty navigator
            auto v = std::make_shared<aron::type::Object>(path);
            v->setObjectName(*private_known_it);
            v->setTemplates({});
            v->setTemplateInstantiations({});
            v->setMemberTypes({});
            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_ATTRIBUTE_NAME))
        {
            return type::Maybe::OPTIONAL;
        }
        if (util::AttributeIsTrue(n, constantes::RAW_PTR_ATTRIBUTE_NAME))
        {
            return type::Maybe::RAW_PTR;
        }
        if (util::AttributeIsTrue(n, constantes::SHARED_PTR_ATTRIBUTE_NAME))
        {
            return type::Maybe::SHARED_PTR;
        }
        if (util::AttributeIsTrue(n, constantes::UNIQUE_PTR_ATTRIBUTE_NAME))
        {
            return type::Maybe::UNIQUE_PTR;
        }
        return type::Maybe::NONE;
    }
 
    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())
        // ensured we are toplevel!
        {
            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 <" +
                    std::string(constantes::GENERATE_TYPES_TAG) + ">-tag.");
        }
 
        const std::string name = util::GetAttribute(node, constantes::NAME_ATTRIBUTE_NAME);
        const std::string extends =
            util::GetAttributeWithDefault(node, constantes::EXTENDS_ATTRIBUTE_NAME, "");
        auto templates = simox::alg::split(
            util::GetAttributeWithDefault(node, constantes::TEMPLATE_ATTRIBUTE_NAME, ""), ",");
 
        auto newObjectInfo = typereader::GenerateObjectInfo();
        newObjectInfo.typeName = name;
        newObjectInfo.doc_brief =
            util::GetAttributeWithDefault(node, constantes::DOC_BRIEF_ATTRIBUTE_NAME, "");
        newObjectInfo.doc_author =
            util::GetAttributeWithDefault(node, constantes::DOC_AUTHOR_ATTRIBUTE_NAME, "");
 
        // reset private known types
        allPreviouslyKnownPrivateTypes = templates;
 
        // set objPath
        aron::Path objPath = path; // copy, just in case there are special things set
        objPath.setRootIdentifier(name); // set the root identifier to the obj 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_ATTRIBUTE_NAME))
            {
                newObjectInfo.doc_members.insert(
                    {key, util::GetAttribute(objectChild, constantes::DOC_BRIEF_ATTRIBUTE_NAME)});
            }
 
            std::vector<RapidXmlReaderNode> children = objectChild.nodes();
 
            auto maybe = getMaybe(children[0]);
            type::VariantPtr childNavigator = create(children[0], objPath.withElement(key));
 
            if (childNavigator->getDescriptor() == aron::type::Descriptor::OBJECT)
            {
                // check if template args are present
                std::vector<std::string> templates =
                    simox::alg::split(util::GetAttributeWithDefault(
                                          children[0], constantes::TEMPLATE_ATTRIBUTE_NAME, ""),
                                      ",");
                auto obj = aron::type::Object::DynamicCastAndCheck(childNavigator);
                for (const auto& t : templates)
                {
                    obj->addTemplateInstantiation(t);
                }
            }
 
            childNavigator->setMaybe(maybe);
            members.insert({key, childNavigator});
        }
 
        // set the new object
        auto aronObjectType = std::make_shared<type::Object>(objPath);
        aronObjectType->setObjectName(name);
        aronObjectType->setTemplates(templates);
        aronObjectType->setTemplateInstantiations({});
        aronObjectType->setMemberTypes(members);
 
        if (extends != "")
        {
            auto parentObj = type::Object::DynamicCastAndCheck(findExistingObject(extends, Path()));
            aronObjectType->setExtends(parentObj);
        }
 
        newObjectInfo.correspondingType = aronObjectType;
        allGeneratedPublicObjects.emplace(newObjectInfo.typeName, newObjectInfo);
 
        allPreviouslyKnownPrivateTypes.clear();
        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.withAcceptedType());
        type->setMaybe(getMaybe(typeNode));
 
        auto o = std::make_shared<type::List>(path);
        o->setAcceptedType(type);
        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.withAcceptedType());
        type->setMaybe(getMaybe(typeNode));
 
        auto o = std::make_shared<type::Dict>(path);
        o->setAcceptedType(type);
        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.withAcceptedTypeIndex(i++));
            type->setMaybe(getMaybe(typeNode));
 
            elementTypes.push_back(type);
        }
 
        auto o = std::make_shared<type::Tuple>(path);
        o->setAcceptedTypes(elementTypes);
        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.withAcceptedTypeIndex(0));
        type1->setMaybe(getMaybe(type1Node));
 
        const RapidXmlReaderNode type2Node = c[1];
        type::VariantPtr type2 = create(type2Node, path.withAcceptedTypeIndex(1));
        type2->setMaybe(getMaybe(type2Node));
 
        auto o = std::make_shared<type::Pair>(path);
        o->setFirstAcceptedType(type1);
        o->setSecondAcceptedType(type2);
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createNDArray(const RapidXmlReaderNode& node, const Path& path) const
    {
        static const std::map<std::string, type::ndarray::ElementType> String2NDArrayType = {
            {constantes::CHAR_SLUG, type::ndarray::ElementType::INT8},
            {constantes::SHORT_SLUG, type::ndarray::ElementType::INT16},
            {constantes::INT_SLUG, type::ndarray::ElementType::INT32},
            {constantes::LONG_SLUG, type::ndarray::ElementType::UINT8},
            {constantes::USHORT_SLUG, type::ndarray::ElementType::UINT16},
            {constantes::UINT_SLUG, type::ndarray::ElementType::UINT32},
            {constantes::FLOAT_SLUG, type::ndarray::ElementType::FLOAT32},
            {constantes::DOUBLE_SLUG, type::ndarray::ElementType::FLOAT64}};
 
        static const std::map<std::string, std::string> StringSlug2NDArrayDefaultValue = {
            {constantes::ONES_SLUG, type::ndarray::default_value::ONES},
            {constantes::ZEROS_SLUG, type::ndarray::default_value::ZEROS}};
 
        auto o = std::make_shared<type::NDArray>(path);
        util::EnforceChildSize(node, 0);
        util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        // TODO
 
        return nullptr;
    }
 
    type::VariantPtr
    ReaderFactory::createMatrix(const RapidXmlReaderNode& node, const Path& path) const
    {
        static const std::map<std::string, type::matrix::ElementType> StringSlug2MatrixType = {
            {constantes::UCHAR_SLUG, type::matrix::ElementType::UINT8},
            {constantes::USHORT_SLUG, type::matrix::ElementType::UINT16},
            {constantes::UINT_SLUG, type::matrix::ElementType::UINT32},
            {constantes::CHAR_SLUG, type::matrix::ElementType::INT8},
            {constantes::SHORT_SLUG, type::matrix::ElementType::INT16},
            {constantes::INT_SLUG, type::matrix::ElementType::INT32},
            {constantes::LONG_SLUG, type::matrix::ElementType::INT64},
            {constantes::FLOAT_SLUG, type::matrix::ElementType::FLOAT32},
            {constantes::DOUBLE_SLUG, type::matrix::ElementType::FLOAT64}};
 
        static const std::map<std::string, std::string> StringSlug2MatrixDefaultValue = {
            {constantes::IDENTITY_SLUG, type::matrix::default_value::IDENTITY},
            {constantes::ONES_SLUG, type::matrix::default_value::ONES},
            {constantes::ZEROS_SLUG, type::matrix::default_value::ZEROS}};
 
        auto o = std::make_shared<type::Matrix>(path);
        util::EnforceChildSize(node, 0);
 
        auto rows_str = util::GetAttributeWithDefault(node, constantes::ROWS_ATTRIBUTE_NAME, "4");
        auto cols_str = util::GetAttributeWithDefault(node, constantes::COLS_ATTRIBUTE_NAME, "4");
 
        // check for unknown size
        if (std::find(constantes::WHATEVER_VALUES.begin(),
                      constantes::WHATEVER_VALUES.end(),
                      simox::alg::to_lower(rows_str)) != constantes::WHATEVER_VALUES.end())
        {
            rows_str = "-1";
        }
        if (std::find(constantes::WHATEVER_VALUES.begin(),
                      constantes::WHATEVER_VALUES.end(),
                      simox::alg::to_lower(cols_str)) != constantes::WHATEVER_VALUES.end())
        {
            cols_str = "-1";
        }
 
        const int rows = std::stoi(rows_str);
        const int cols = std::stoi(cols_str);
 
        // set rows and cols
        o->setRows(rows);
        o->setCols(cols);
 
        // get type
        std::string type = util::GetAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        ARMARX_CHECK_AND_THROW(
            StringSlug2MatrixType.count(simox::alg::to_lower(type)),
            error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not resolve type", type));
 
        // set elem type
        o->setElementType(StringSlug2MatrixType.at(simox::alg::to_lower(type)));
 
        // set default
        const std::string def = simox::alg::to_lower(util::GetAttributeWithDefault(
            node, constantes::DEFAULT_ATTRIBUTE_NAME, type::matrix::default_value::DEFAULT));
 
        if (const auto it = StringSlug2MatrixDefaultValue.find(def);
            it != StringSlug2MatrixDefaultValue.end())
        {
            o->setDefaultValue(it->second);
        }
        else if (def == type::matrix::default_value::DEFAULT)
        {
            o->setDefaultValue(def);
        }
        else
        {
            util::EnforceStrIsNumber(def);
            o->setDefaultValue(def);
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createQuaternion(const RapidXmlReaderNode& node, const Path& path) const
    {
        static const std::map<std::string, type::quaternion::ElementType>
            StringSlug2QuaternionType = {
                {constantes::FLOAT_SLUG, type::quaternion::ElementType::FLOAT32},
                {constantes::DOUBLE_SLUG, type::quaternion::ElementType::FLOAT64}};
 
        static const std::map<std::string, std::string> StringSlug2QuaternionDefaultValue = {
            {constantes::ONES_SLUG, type::quaternion::default_value::ONES},
            {constantes::ZEROS_SLUG, type::quaternion::default_value::ZEROS}};
 
        auto o = std::make_shared<type::Quaternion>(path);
        util::EnforceChildSize(node, 0);
        util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        // set elem type
        std::string type = util::GetAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
        ARMARX_CHECK_AND_THROW(
            StringSlug2QuaternionType.count(simox::alg::to_lower(type)),
            error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not resolve type", type));
 
        o->setElementType(StringSlug2QuaternionType.at(simox::alg::to_lower(type)));
 
        // set default
        const std::string def = simox::alg::to_lower(util::GetAttributeWithDefault(
            node, constantes::DEFAULT_ATTRIBUTE_NAME, type::quaternion::default_value::DEFAULT));
 
        if (const auto it = StringSlug2QuaternionDefaultValue.find(def);
            it != StringSlug2QuaternionDefaultValue.end())
        {
            o->setDefaultValue(it->second);
        }
        else if (def == type::quaternion::default_value::DEFAULT)
        {
            o->setDefaultValue(def);
        }
        else
        {
            util::EnforceStrIsNumberSeq(def);
            o->setDefaultValue(def);
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createImage(const RapidXmlReaderNode& node, const Path& path) const
    {
        static const std::map<std::string, type::image::PixelType> String2PixelType = {
            {constantes::RGB_SLUG, type::image::PixelType::RGB24},
            {constantes::DEPTH_SLUG, type::image::PixelType::DEPTH32}};
 
        static const std::map<std::string, std::string> StringSlug2ImageDefaultValue = {
            {constantes::IDENTITY_SLUG, type::image::default_value::IDENTITY},
            {constantes::ONES_SLUG, type::image::default_value::ONES},
            {constantes::ZEROS_SLUG, type::image::default_value::ZEROS}};
 
        auto o = std::make_shared<type::Image>(path);
        util::EnforceChildSize(node, 0);
        util::EnforceAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        // set elem type
        std::string type = util::GetAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        ARMARX_CHECK_AND_THROW(
            String2PixelType.count(simox::alg::to_lower(type)),
            error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not resolve type", type));
 
        o->setPixelType(String2PixelType.at(simox::alg::to_lower(type)));
 
        // set default
        const std::string def = simox::alg::to_lower(util::GetAttributeWithDefault(
            node, constantes::DEFAULT_ATTRIBUTE_NAME, type::image::default_value::DEFAULT));
 
        if (const auto it = StringSlug2ImageDefaultValue.find(def);
            it != StringSlug2ImageDefaultValue.end())
        {
            o->setDefaultValue(it->second);
        }
        else if (def == type::image::default_value::DEFAULT)
        {
            o->setDefaultValue(def);
        }
        else
        {
            util::EnforceStrIsNumber(def);
            o->setDefaultValue(def);
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createPointCloud(const RapidXmlReaderNode& node, const Path& path) const
    {
        static const std::map<std::string, type::pointcloud::VoxelType> StringSlug2VoxelType = {
            {constantes::POINT_XYZ_SLUG, type::pointcloud::VoxelType::POINT_XYZ},
            {constantes::POINT_XYZI_SLUG, type::pointcloud::VoxelType::POINT_XYZI},
            {constantes::POINT_XYZL_SLUG, type::pointcloud::VoxelType::POINT_XYZL},
            {constantes::POINT_XYZRGB_SLUG, type::pointcloud::VoxelType::POINT_XYZRGB},
            {constantes::POINT_XYZRGBL_SLUG, type::pointcloud::VoxelType::POINT_XYZRGBL},
            {constantes::POINT_XYZRGBA_SLUG, type::pointcloud::VoxelType::POINT_XYZRGBA},
            {constantes::POINT_XYZHSV_SLUG, type::pointcloud::VoxelType::POINT_XYZHSV}};
 
        static const std::map<std::string, std::string> StringSlug2PointCloudDefaultValue = {
            {constantes::IDENTITY_SLUG, type::pointcloud::default_value::IDENTITY},
            {constantes::ONES_SLUG, type::pointcloud::default_value::ONES},
            {constantes::ZEROS_SLUG, type::pointcloud::default_value::ZEROS}};
 
        auto o = std::make_shared<type::PointCloud>(path);
        util::EnforceChildSize(node, 0);
 
        // set elem type
        std::string type = util::GetAttribute(node, constantes::TYPE_ATTRIBUTE_NAME);
 
        ARMARX_CHECK_AND_THROW(
            StringSlug2VoxelType.count(simox::alg::to_lower(type)),
            error::ValueNotValidException(__PRETTY_FUNCTION__, "Could not resolve type", type));
 
        o->setVoxelType(StringSlug2VoxelType.at(simox::alg::to_lower(type)));
 
        // set default
        const std::string def = simox::alg::to_lower(util::GetAttributeWithDefault(
            node, constantes::DEFAULT_ATTRIBUTE_NAME, type::pointcloud::default_value::DEFAULT));
 
        if (const auto it = StringSlug2PointCloudDefaultValue.find(def);
            it != StringSlug2PointCloudDefaultValue.end())
        {
            o->setDefaultValue(it->second);
        }
        else if (def == type::pointcloud::default_value::DEFAULT)
        {
            o->setDefaultValue(def);
        }
        else
        {
            util::EnforceStrIsNumber(def);
            o->setDefaultValue(def);
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createIntEnum(const RapidXmlReaderNode& node, const Path& path)
    {
        if (path.hasElement())
        // ensured we are top-level!
        {
            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 <" +
                    std::string(constantes::GENERATE_TYPES_TAG) + ">-tag.");
        }
 
        const std::string name = util::GetAttribute(node, constantes::NAME_ATTRIBUTE_NAME);
 
        auto newEnumInfo = typereader::GenerateIntEnumInfo();
        newEnumInfo.typeName = name;
 
        allPreviouslyKnownPrivateTypes.clear();
 
        std::string defaultValue = util::GetAttributeWithDefault(
            node, constantes::DEFAULT_ATTRIBUTE_NAME, type::aron_enum::default_value::DEFAULT);
 
        // get accepted values
        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_ATTRIBUTE_NAME))
            {
                newEnumInfo.doc_values.insert(
                    {key, util::GetAttribute(valueChild, constantes::DOC_BRIEF_ATTRIBUTE_NAME)});
            }
 
            const std::string value =
                util::GetAttribute(valueChild, constantes::VALUE_ATTRIBUTE_NAME);
 
            // Overwrite default value if child is tagged as default
            if (util::AttributeIsTrue(valueChild, constantes::DEFAULT_ATTRIBUTE_NAME))
            {
                defaultValue = key;
            }
 
            acceptedValues.emplace(key, std::stoi(value));
        }
 
        if (acceptedValues.size() == 0)
        {
            printWarning("Found enum '" + name + "' without any members...");
        }
 
        // check default value
        if (defaultValue != type::aron_enum::default_value::DEFAULT and
            not acceptedValues.count(defaultValue))
        {
            throw error::ValueNotValidException(__PRETTY_FUNCTION__,
                                                "An int enum has a non existing default value set",
                                                defaultValue);
        }
 
 
        // create the int enum
        aron::Path enumPath = path; // copy, just in case there are special things set
        enumPath.setRootIdentifier(name); // set the root identifier to the obj name
        auto o = std::make_shared<type::IntEnum>(enumPath);
        o->setEnumName(name);
        o->setAcceptedValueMap(acceptedValues);
        o->setDefaultValueName(defaultValue);
        newEnumInfo.correspondingType = o;
 
        allGeneratedPublicIntEnums.emplace(newEnumInfo.typeName, newEnumInfo);
 
        allPreviouslyKnownPrivateTypes.clear();
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createInt(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::Int>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            util::EnforceStrIsInt(def);
            o->setDefaultValue(simox::alg::to_<int>(def));
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createLong(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::Long>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            util::EnforceStrIsInt(def);
            o->setDefaultValue(simox::alg::to_<long>(def));
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createFloat(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::Float>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            util::EnforceStrIsFloat(def);
            o->setDefaultValue(simox::alg::to_<float>(def));
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createDouble(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::Double>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            util::EnforceStrIsFloat(def);
            o->setDefaultValue(simox::alg::to_<double>(def));
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createString(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::String>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            o->setDefaultValue(def);
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createBool(const RapidXmlReaderNode& node, const Path& path) const
    {
        auto o = std::make_shared<type::Bool>(path);
 
        if (util::HasAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME))
        {
            const std::string def = util::GetAttribute(node, constantes::DEFAULT_ATTRIBUTE_NAME);
            util::EnforceStrIsBool(def);
            o->setDefaultValue(simox::alg::to_<bool>(def));
        }
 
        return o;
    }
 
    type::VariantPtr
    ReaderFactory::createAnyObject(const RapidXmlReaderNode& node, const Path& path) const
    {
        return std::make_shared<type::AnyObject>(path);
    }
} // namespace armarx::aron::typereader::xml