Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • sw/armarx/robot-api
  • uwkce_singer/robot-api
  • untcg_hofmann/robot-api
  • ulqba_korosakov/RobotAPI
4 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 507 additions and 225 deletions
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp
View file @ 4ee3e4f3
......@@ -26,14 +26,14 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
const std::map<type::quaternion::ElementType, std::tuple<std::string, int, std::string>> ElementType2Cpp =
{
{type::quaternion::ElementType::FLOAT32, {"float", 4, "::armarx::aron::type::quaternion::ElementType::FLOAT32"}},
{type::quaternion::ElementType::FLOAT64, {"double", 8, "::armarx::aron::type::quaternion::ElementType::FLOAT64"}}
};
const std::map<type::quaternion::ElementType, std::tuple<std::string, int, std::string>>
ElementType2Cpp = {
{type::quaternion::ElementType::FLOAT32,
{"float", 4, "::armarx::aron::type::quaternion::ElementType::FLOAT32"}},
{type::quaternion::ElementType::FLOAT64,
{"double", 8, "::armarx::aron::type::quaternion::ElementType::FLOAT64"}}};
// constructors
Quaternion::Quaternion(const type::Quaternion& n) :
......@@ -46,45 +46,85 @@ namespace armarx::aron::codegenerator::cpp::generator
{
}
std::vector<std::string> Quaternion::getRequiredIncludes() const
std::vector<std::string>
Quaternion::getRequiredIncludes() const
{
return {"<Eigen/Core>", "<Eigen/Geometry>"};
}
CppBlockPtr Quaternion::getResetSoftBlock(const std::string& cppAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Quaternion::getCtorInitializers(const std::string& name) const
{
if (type.getDefaultValue() == aron::type::quaternion::default_value::DEFAULT)
{
return {{}, false};
}
if (type.getDefaultValue() == aron::type::quaternion::default_value::ZEROS)
{
return {{{name, getInstantiatedCppTypename() + "(0, 0, 0, 0)"}}, true};
}
if (type.getDefaultValue() == aron::type::quaternion::default_value::ONES)
{
return {{{name, getInstantiatedCppTypename() + "(1, 1, 1, 1)"}}, true};
}
else
{
// try to parse num. We ensure from typereader that defaultValue is valid number
return {{{name, getInstantiatedCppTypename() + "(" + type.getDefaultValue() + ")"}},
true};
}
}
CppBlockPtr
Quaternion::getResetSoftBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + nextEl() + "setIdentity();");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
CppBlockPtr Quaternion::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
Quaternion::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(cppAccessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeQuaternion(" + std::get<2>(ElementType2Cpp.at(type.getElementType())) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + cppAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeQuaternion(" +
std::get<2>(ElementType2Cpp.at(type.getElementType())) + ", " + "\"" +
type.getDefaultValue() + "\", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return b;
}
CppBlockPtr Quaternion::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
Quaternion::getWriteBlock(const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(cppAccessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
block_if_data->addLine(variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeNDArray({1, 4, " + std::to_string(std::get<1>(ElementType2Cpp.at(type.getElementType()))) + "}, "+
"\"" + std::get<0>(ElementType2Cpp.at(type.getElementType())) + "\", "+
"reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data()), "+
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {" + simox::alg::join(p.getPath(), ", ") + "})); // of " + cppAccessor);
block_if_data->addLine(
variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeNDArray({1, 4, " +
std::to_string(std::get<1>(ElementType2Cpp.at(type.getElementType()))) + "}, " + "\"" +
std::get<0>(ElementType2Cpp.at(type.getElementType())) + "\", " +
"reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() +
"coeffs().data()), " + "armarx::aron::Path(" + ARON_PATH_ACCESSOR + ", {" +
simox::alg::join(p.getPath(), ", ") + "})); // of " + cppAccessor);
return resolveMaybeWriteBlock(block_if_data, cppAccessor);
}
CppBlockPtr Quaternion::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
CppBlockPtr
Quaternion::getReadBlock(const std::string& cppAccessor,
const std::string& variantAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(cppAccessor);
......@@ -95,16 +135,22 @@ namespace armarx::aron::codegenerator::cpp::generator
block_if_data->addLine("std::string " + type + ";");
block_if_data->addLine("std::vector<int> " + dims + ";");
block_if_data->addLine("std::vector<unsigned char> " + data + ";");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readNDArray("+variantAccessor+", "+dims+", "+type+", "+data+"); // of " + cppAccessor);
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "coeffs().data()), "+data+".data(), "+data+".size());");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readNDArray(" + variantAccessor +
", " + dims + ", " + type + ", " + data + "); // of " + cppAccessor);
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor +
nextEl() + "coeffs().data()), " + data + ".data(), " + data +
".size());");
return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
}
CppBlockPtr Quaternion::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
CppBlockPtr
Quaternion::getEqualsBlock(const std::string& accessor,
const std::string& otherInstanceAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" + otherInstanceAccessor + ")))");
block_if_data->addLine("if (not (" + accessor + nextEl() + "isApprox(" +
otherInstanceAccessor + ")))");
block_if_data->addLineAsBlock("return false;");
return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.h
View file @ 4ee3e4f3
......@@ -24,16 +24,14 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h>
#include <map>
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Quaternion.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Quaternion :
public detail::NDArrayGenerator<type::Quaternion, Quaternion>
class Quaternion : public detail::NDArrayGenerator<type::Quaternion, Quaternion>
{
public:
// constructors
......@@ -42,10 +40,18 @@ namespace armarx::aron::codegenerator::cpp::generator
// virtual implementations
std::vector<std::string> getRequiredIncludes() const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) 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;
CppBlockPtr getWriteBlock(const std::string& cppAccessor, const Path&, std::string& variantAccessor) const final;
CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path&,
std::string& variantAccessor) const final;
CppBlockPtr getWriteBlock(const std::string& cppAccessor,
const Path&,
std::string& variantAccessor) const final;
CppBlockPtr getReadBlock(const std::string& cppAccessor,
const std::string& variantAccessor) const final;
CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Bool.cpp
View file @ 4ee3e4f3
......@@ -25,7 +25,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
......@@ -34,33 +33,49 @@ namespace armarx::aron::codegenerator::cpp::generator
"bool",
"bool",
simox::meta::get_type_name<data::dto::AronBool>(),
simox::meta::get_type_name<type::dto::AronBool>(), e)
simox::meta::get_type_name<type::dto::AronBool>(),
e)
{
}
/* virtual implementations */
CppBlockPtr Bool::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Bool::getCtorInitializers(const std::string& name) const
{
return {{{name, std::to_string(type.getDefaultValue())}}, true};
}
CppBlockPtr
Bool::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeBool(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeBool(" +
std::to_string(type.getDefaultValue()) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr Bool::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Bool::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = false;");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr Bool::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Bool::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = false;");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Bool.h
View file @ 4ee3e4f3
......@@ -23,24 +23,29 @@
#pragma once
#include "../detail/PrimitiveGenerator.h"
#include <RobotAPI/libraries/aron/core/type/variant/primitive/Bool.h>
#include "../detail/PrimitiveGenerator.h"
namespace armarx::aron::codegenerator::cpp::generator
{
class Bool :
public detail::PrimitiveGenerator<type::Bool, Bool>
class Bool : public detail::PrimitiveGenerator<type::Bool, Bool>
{
public:
static const constexpr bool DEFAULT_DEFAULT = false;
/* constructors */
Bool(const type::Bool& e);
virtual ~Bool() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Double.cpp
View file @ 4ee3e4f3
......@@ -25,7 +25,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
......@@ -40,28 +39,43 @@ namespace armarx::aron::codegenerator::cpp::generator
}
/* virtual implementations */
CppBlockPtr Double::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Double::getCtorInitializers(const std::string& name) const
{
return {{{name, std::to_string(type.getDefaultValue())}}, true};
}
CppBlockPtr
Double::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeDouble(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeDouble(" +
std::to_string(type.getDefaultValue()) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr Double::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Double::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0.0;");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr Double::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Double::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0.0;");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Double.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/Double.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Double :
public detail::PrimitiveGenerator<type::Double, Double>
class Double : public detail::PrimitiveGenerator<type::Double, Double>
{
public:
/* constructors */
......@@ -38,8 +36,13 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~Double() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Float.cpp
View file @ 4ee3e4f3
......@@ -25,7 +25,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
......@@ -40,28 +39,43 @@ namespace armarx::aron::codegenerator::cpp::generator
}
/* virtual implementations */
CppBlockPtr Float::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Float::getCtorInitializers(const std::string& name) const
{
return {{{name, std::to_string(type.getDefaultValue())}}, true};
}
CppBlockPtr
Float::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeFloat(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeFloat(" +
std::to_string(type.getDefaultValue()) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr Float::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Float::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0.0f;");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr Float::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Float::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0.0f;");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Float.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/Float.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Float :
public detail::PrimitiveGenerator<type::Float, Float>
class Float : public detail::PrimitiveGenerator<type::Float, Float>
{
public:
/* constructors */
......@@ -38,8 +36,13 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~Float() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Int.cpp
View file @ 4ee3e4f3
......@@ -25,43 +25,56 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
Int::Int(const type::Int& e) :
detail::PrimitiveGenerator<type::Int, Int>(
"int",
"int",
simox::meta::get_type_name<data::dto::AronInt>(),
simox::meta::get_type_name<type::dto::AronInt>(),
e)
detail::PrimitiveGenerator<type::Int, Int>("int",
"int",
simox::meta::get_type_name<data::dto::AronInt>(),
simox::meta::get_type_name<type::dto::AronInt>(),
e)
{
}
/* virtual implementations */
CppBlockPtr Int::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Int::getCtorInitializers(const std::string& name) const
{
return {{{name, std::to_string(type.getDefaultValue())}}, true};
}
CppBlockPtr
Int::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeInt(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeInt(" +
std::to_string(type.getDefaultValue()) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr Int::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Int::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0;");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr Int::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Int::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0;");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Int.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/Int.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Int :
public detail::PrimitiveGenerator<type::Int, Int>
class Int : public detail::PrimitiveGenerator<type::Int, Int>
{
public:
/* constructors */
......@@ -38,8 +36,13 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~Int() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Long.cpp
View file @ 4ee3e4f3
......@@ -25,7 +25,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
......@@ -40,28 +39,43 @@ namespace armarx::aron::codegenerator::cpp::generator
}
/* virtual implementations */
CppBlockPtr Long::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Long::getCtorInitializers(const std::string& name) const
{
return {{{name, std::to_string(type.getDefaultValue())}}, true};
}
CppBlockPtr
Long::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeLong(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeLong(" +
std::to_string(type.getDefaultValue()) + ", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr Long::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Long::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0;");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr Long::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Long::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = 0;");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/Long.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/Long.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Long :
public detail::PrimitiveGenerator<type::Long, Long>
class Long : public detail::PrimitiveGenerator<type::Long, Long>
{
public:
/* constructors */
......@@ -38,8 +36,13 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~Long() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/String.cpp
View file @ 4ee3e4f3
......@@ -25,7 +25,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
/* constructors */
......@@ -40,28 +39,43 @@ namespace armarx::aron::codegenerator::cpp::generator
}
/* virtual implementations */
CppBlockPtr String::getWriteTypeBlock(const std::string& typeAccessor, const std::string& accessor, const Path& p, std::string& variantAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
String::getCtorInitializers(const std::string& name) const
{
return {{{name, "\"" + type.getDefaultValue() + "\""}}, true};
}
CppBlockPtr
String::getWriteTypeBlock(const std::string& typeAccessor,
const std::string& accessor,
const Path& p,
std::string& variantAccessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(accessor);
variantAccessor = ARON_VARIANT_RETURN_ACCESSOR + "_" + escaped_accessor;
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeString(" + conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + typeAccessor);
b->addLine("auto " + variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeString(\"" +
type.getDefaultValue() + "\", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + typeAccessor);
return b;
}
CppBlockPtr String::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
String::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = \"\";");
return resolveMaybeResetHardBlock(block_if_data, cppAccessor);
}
CppBlockPtr String::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
String::getResetSoftBlock(const std::string& cppAccessor) const
{
auto block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = \"\";");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/primitive/String.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/PrimitiveGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/primitive/String.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class String :
public detail::PrimitiveGenerator<type::String, String>
class String : public detail::PrimitiveGenerator<type::String, String>
{
public:
/* constructors */
......@@ -38,8 +36,13 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~String() = default;
/* virtual implementations */
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const final;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path& p,
std::string& variantAccessor) const final;
CppBlockPtr getResetSoftBlock(const std::string& cppAccessor) const final;
CppBlockPtr getResetHardBlock(const std::string& cppAccessor) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.cpp
View file @ 4ee3e4f3
......@@ -26,7 +26,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
// constructors
......@@ -40,11 +39,16 @@ namespace armarx::aron::codegenerator::cpp::generator
{
if (type.getMaybe() != type::Maybe::NONE)
{
throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Somehow the maybe flag of a top level int enum declaration is set. This is not valid!", std::to_string((int) type.getMaybe()), type.getPath());
throw error::ValueNotValidException(__PRETTY_FUNCTION__,
"Somehow the maybe flag of a top level int enum "
"declaration is set. This is not valid!",
std::to_string((int)type.getMaybe()),
type.getPath());
}
}
std::vector<CppFieldPtr> IntEnumClass::getPublicVariableDeclarations(const std::string& className) const
std::vector<CppFieldPtr>
IntEnumClass::getPublicVariableDeclarations(const std::string& className) const
{
std::vector<CppFieldPtr> fields;
std::stringstream enum_to_name;
......@@ -53,7 +57,11 @@ namespace armarx::aron::codegenerator::cpp::generator
std::stringstream value_to_enum;
// 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"));
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);
......@@ -64,7 +72,8 @@ namespace armarx::aron::codegenerator::cpp::generator
for (const auto& [key, value] : type.getAcceptedValueMap())
{
std::string enumKeyWithNamespace = std::string(IMPL_ENUM) + "::" + key;
fields.push_back(std::make_shared<CppField>("static constexpr " + std::string(IMPL_ENUM), key + " = " + enumKeyWithNamespace));
fields.push_back(std::make_shared<CppField>(
"static constexpr " + std::string(IMPL_ENUM), key + " = " + enumKeyWithNamespace));
enum_to_name << "\t\t{" << enumKeyWithNamespace << ", \"" << key << "\"}," << std::endl;
name_to_enum << "\t\t{\"" << key << "\", " << enumKeyWithNamespace << "}," << std::endl;
......@@ -78,31 +87,56 @@ namespace armarx::aron::codegenerator::cpp::generator
enum_to_value << "\t}";
value_to_enum << "\t}";
fields.push_back(std::make_shared<CppField>("static inline const std::map<" + std::string(IMPL_ENUM) + ", std::string>", "EnumToStringMap", enum_to_name.str(), "Mapping enum values to readable strings"));
fields.push_back(std::make_shared<CppField>("static inline const std::map<std::string, " + std::string(IMPL_ENUM) + ">", "StringToEnumMap", name_to_enum.str(), "Mapping readable strings to enum values"));
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", type.getAcceptedValueNames()[0], "The current value of the enum object"));
fields.push_back(std::make_shared<CppField>("static inline const std::map<" +
std::string(IMPL_ENUM) + ", std::string>",
"EnumToStringMap",
enum_to_name.str(),
"Mapping enum values to readable strings"));
fields.push_back(std::make_shared<CppField>("static inline const std::map<std::string, " +
std::string(IMPL_ENUM) + ">",
"StringToEnumMap",
name_to_enum.str(),
"Mapping readable strings to enum values"));
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",
type.getAcceptedValueNames()[0],
"The current value of the enum object"));
return fields;
}
CppBlockPtr IntEnumClass::getResetSoftBlock(const std::string& accessor) const
CppBlockPtr
IntEnumClass::getResetSoftBlock(const std::string& accessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("value = {};");
return block_if_data;
}
CppBlockPtr IntEnumClass::getResetHardBlock(const std::string& accessor) const
CppBlockPtr
IntEnumClass::getResetHardBlock(const std::string& accessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("value = {};");
return block_if_data;
}
CppBlockPtr IntEnumClass::getWriteTypeBlock(const std::string&, const std::string&, const Path& p, std::string&) const
CppBlockPtr
IntEnumClass::getWriteTypeBlock(const std::string&,
const std::string&,
const Path& p,
std::string&) const
{
static const std::string INT_ENUM_VALUE_MAP = ARON_VARIABLE_PREFIX + "_str2ValueMap";
......@@ -113,40 +147,50 @@ namespace armarx::aron::codegenerator::cpp::generator
{
map_initializer.push_back("{\"" + key + "\", " + std::to_string(value) + "}");
}
b->addLine("std::map<std::string, int> " + INT_ENUM_VALUE_MAP + " = {" + simox::alg::to_string(map_initializer, ", ") + "};");
b->addLine("return " + ARON_WRITER_ACCESSOR + ".writeIntEnum(\"" + type.getEnumName() + "\", " +
INT_ENUM_VALUE_MAP + ", " +
ARON_MAYBE_TYPE_ACCESSOR + ", " +
ARON_PATH_ACCESSOR + ");");
return b;
b->addLine("std::map<std::string, int> " + INT_ENUM_VALUE_MAP + " = {" +
simox::alg::to_string(map_initializer, ", ") + "};");
b->addLine("return " + ARON_WRITER_ACCESSOR + ".writeIntEnum(\"" + type.getEnumName() +
"\", " + INT_ENUM_VALUE_MAP + ", " + "\"" + type.getDefaultValueName() + "\", " +
ARON_MAYBE_TYPE_ACCESSOR + ", " + ARON_PATH_ACCESSOR + ");");
return b;
}
CppBlockPtr IntEnumClass::getWriteBlock(const std::string&, const Path& p, std::string&) const
CppBlockPtr
IntEnumClass::getWriteBlock(const std::string&, const Path& p, std::string&) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("return " + ARON_WRITER_ACCESSOR + ".writePrimitive(EnumToValueMap.at(value), " +
ARON_PATH_ACCESSOR + "); // of top level enum " + getInstantiatedCppTypename());
block_if_data->addLine("return " + ARON_WRITER_ACCESSOR +
".writePrimitive(EnumToValueMap.at(value), " + ARON_PATH_ACCESSOR +
"); // of top level enum " + getInstantiatedCppTypename());
return block_if_data;
}
CppBlockPtr IntEnumClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
CppBlockPtr
IntEnumClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
{
static const std::string INT_ENUM_TMP_VALUE = ARON_VARIABLE_PREFIX + "_tmpValue";
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("int " + INT_ENUM_TMP_VALUE + ";");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readPrimitive("+variantAccessor+", "+INT_ENUM_TMP_VALUE+"); // of top level enum " + getInstantiatedCppTypename());
block_if_data->addLine("auto valueToEnumMap_iterator = ValueToEnumMap.find("+INT_ENUM_TMP_VALUE+");");
block_if_data->addLine("ARMARX_CHECK_AND_THROW(valueToEnumMap_iterator != ValueToEnumMap.end(), ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Missing enum for value '\" + std::to_string(" + INT_ENUM_TMP_VALUE + ") + \"' in aron enum '" + getFullClassCppTypename() + "'.\"))");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readPrimitive(" + variantAccessor +
", " + INT_ENUM_TMP_VALUE + "); // of top level enum " +
getInstantiatedCppTypename());
block_if_data->addLine("auto valueToEnumMap_iterator = ValueToEnumMap.find(" +
INT_ENUM_TMP_VALUE + ");");
block_if_data->addLine(
"ARMARX_CHECK_AND_THROW(valueToEnumMap_iterator != ValueToEnumMap.end(), "
"::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Missing enum for value "
"'\" + std::to_string(" +
INT_ENUM_TMP_VALUE + ") + \"' in aron enum '" + getFullClassCppTypename() + "'.\"))");
block_if_data->addLine("value = valueToEnumMap_iterator->second;");
return block_if_data;
}
CppBlockPtr IntEnumClass::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
CppBlockPtr
IntEnumClass::getEqualsBlock(const std::string& accessor,
const std::string& otherInstanceAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("if (not (value == " + otherInstanceAccessor + ".value))");
......@@ -154,7 +198,6 @@ namespace armarx::aron::codegenerator::cpp::generator
return block_if_data;
}
/*CppCtorPtr IntEnumClass::toCopyCtor(const std::string& name) const
{
CppCtorPtr c = std::make_shared<CppCtor>(name + "(const " + getFullInstantiatedCppTypename() + "& i)");
......@@ -164,7 +207,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return c;
}*/
CppCtorPtr IntEnumClass::toEnumCtor(const std::string& name) const
CppCtorPtr
IntEnumClass::toEnumCtor(const std::string& name) const
{
CppCtorPtr c = std::make_shared<CppCtor>(name + "(const " + std::string(IMPL_ENUM) + " e)");
std::vector<std::pair<std::string, std::string>> initList = {{"value", "e"}};
......@@ -173,7 +217,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return c;
}
std::vector<CppEnumFieldPtr> IntEnumClass::toEnumFields() const
std::vector<CppEnumFieldPtr>
IntEnumClass::toEnumFields() const
{
std::vector<CppEnumFieldPtr> e;
for (const auto& [key, value] : type.getAcceptedValueMap())
......@@ -183,7 +228,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return e;
}
CppMethodPtr IntEnumClass::toIntMethod() const
CppMethodPtr
IntEnumClass::toIntMethod() const
{
std::stringstream doc;
doc << "@brief int() - Converts the internally stored value to int representation \n";
......@@ -196,13 +242,17 @@ namespace armarx::aron::codegenerator::cpp::generator
return m;
}
CppMethodPtr IntEnumClass::toCopyAssignmentMethod() const
CppMethodPtr
IntEnumClass::toCopyAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for copy \n";
doc << "@return - nothing";
CppMethodPtr m = CppMethodPtr(new CppMethod(getFullInstantiatedCppTypename() + "& operator=(const " + getFullInstantiatedCppTypename() + "& c)", doc.str()));
CppMethodPtr m =
CppMethodPtr(new CppMethod(getFullInstantiatedCppTypename() + "& operator=(const " +
getFullInstantiatedCppTypename() + "& c)",
doc.str()));
CppBlockPtr b = std::make_shared<CppBlock>();
b->addLine("value = c.value;");
b->addLine("return *this;");
......@@ -210,13 +260,16 @@ namespace armarx::aron::codegenerator::cpp::generator
return m;
}
CppMethodPtr IntEnumClass::toEnumAssignmentMethod() const
CppMethodPtr
IntEnumClass::toEnumAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for the internally defined enum \n";
doc << "@return - nothing";
CppMethodPtr m = CppMethodPtr(new CppMethod(getFullInstantiatedCppTypename() + "& operator=(" + std::string(IMPL_ENUM) + " v)", doc.str()));
CppMethodPtr m = CppMethodPtr(new CppMethod(
getFullInstantiatedCppTypename() + "& operator=(" + std::string(IMPL_ENUM) + " v)",
doc.str()));
CppBlockPtr b = std::make_shared<CppBlock>();
b->addLine("value = v;");
b->addLine("return *this;");
......@@ -224,17 +277,20 @@ namespace armarx::aron::codegenerator::cpp::generator
return m;
}
CppMethodPtr IntEnumClass::toIntAssignmentMethod() const
CppMethodPtr
IntEnumClass::toIntAssignmentMethod() const
{
std::stringstream doc;
doc << "@brief operator=() - Assignment operator for the internally defined enum \n";
doc << "@return - nothing";
CppMethodPtr m = CppMethodPtr(new CppMethod(getFullInstantiatedCppTypename() + "& operator=(int v)", doc.str()));
CppMethodPtr m = CppMethodPtr(
new CppMethod(getFullInstantiatedCppTypename() + "& operator=(int v)", doc.str()));
CppBlockPtr b = std::make_shared<CppBlock>();
b->addLine("if (auto it = ValueToEnumMap.find(v); it == ValueToEnumMap.end())");
CppBlockPtr b2 = std::make_shared<CppBlock>();
b2->addLine("throw armarx::LocalException(\"The input int is not valid. Could net set the enum to value '\" + std::to_string(v) + \"'\");");
b2->addLine("throw armarx::LocalException(\"The input int is not valid. Could net set the "
"enum to value '\" + std::to_string(v) + \"'\");");
b->addBlock(b2);
b->addLine("else");
CppBlockPtr b3 = std::make_shared<CppBlock>();
......@@ -245,7 +301,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return m;
}
CppMethodPtr IntEnumClass::toToStringMethod() const
CppMethodPtr
IntEnumClass::toToStringMethod() const
{
std::stringstream doc;
doc << "@brief toString() - Converts the internally stored value to string \n";
......@@ -258,17 +315,21 @@ namespace armarx::aron::codegenerator::cpp::generator
return m;
}
CppMethodPtr IntEnumClass::toFromStringMethod() const
CppMethodPtr
IntEnumClass::toFromStringMethod() const
{
std::stringstream doc;
doc << "@brief fromString() - sets the internally stored value to the corrsponding enum of the input str \n";
doc << "@brief fromString() - sets the internally stored value to the corrsponding enum of "
"the input str \n";
doc << "@return - nothing";
CppMethodPtr m = CppMethodPtr(new CppMethod("void fromString(const std::string& str)", doc.str()));
CppMethodPtr m =
CppMethodPtr(new CppMethod("void fromString(const std::string& str)", doc.str()));
CppBlockPtr b = std::make_shared<CppBlock>();
b->addLine("if (auto it = StringToEnumMap.find(str); it == StringToEnumMap.end())");
CppBlockPtr b2 = std::make_shared<CppBlock>();
b2->addLine("throw armarx::LocalException(\"The input name is not valid. Could net set the enum to value '\" + str + \"'\");");
b2->addLine("throw armarx::LocalException(\"The input name is not valid. Could net set the "
"enum to value '\" + str + \"'\");");
b->addBlock(b2);
b->addLine("else");
CppBlockPtr b3 = std::make_shared<CppBlock>();
......@@ -278,4 +339,4 @@ namespace armarx::aron::codegenerator::cpp::generator
m->setBlock(b);
return m;
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/IntEnumClass.h
View file @ 4ee3e4f3
......@@ -23,17 +23,15 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
#include <map>
#include <utility> // std::pair
#include <utility> // std::pair
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/enum/IntEnum.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class IntEnumClass :
public detail::SpecializedGeneratorBase<type::IntEnum, IntEnumClass>
class IntEnumClass : public detail::SpecializedGeneratorBase<type::IntEnum, IntEnumClass>
{
public:
// constructors
......@@ -45,9 +43,15 @@ namespace armarx::aron::codegenerator::cpp::generator
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;
CppBlockPtr getWriteBlock(const std::string& cppAccessor, const Path&, std::string& variantAccessor) const final;
CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path&,
std::string& variantAccessor) const final;
CppBlockPtr getWriteBlock(const std::string& cppAccessor,
const Path&,
std::string& variantAccessor) const final;
CppBlockPtr getReadBlock(const std::string& cppAccessor,
const std::string& variantAccessor) const final;
CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const final;
// TODO: Move some of those methods to upper class for enums (if we want to support multiple enums)
......@@ -66,4 +70,4 @@ namespace armarx::aron::codegenerator::cpp::generator
static const std::map<std::string, std::pair<std::string, int>> ACCEPTED_TYPES;
static constexpr const char* IMPL_ENUM = "ImplEnum";
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.cpp
View file @ 4ee3e4f3
......@@ -24,9 +24,8 @@
// Header
#include "ObjectClass.h"
#include <SimoxUtility/meta/type_name.h>
#include <SimoxUtility/algorithm/vector.hpp>
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
......@@ -36,27 +35,54 @@ namespace armarx::aron::codegenerator::cpp::generator
e.getObjectNameWithTemplateInstantiations(), // should be similar to the object name
e.getObjectNameWithTemplates(),
simox::meta::get_type_name<data::dto::Dict>(),
simox::meta::get_type_name<type::dto::AronObject>(), e)
simox::meta::get_type_name<type::dto::AronObject>(),
e)
{
if (type.getMaybe() != type::Maybe::NONE)
{
throw error::ValueNotValidException(__PRETTY_FUNCTION__, "Somehow the maybe flag of a top level object declaration is set. This is not valid!", std::to_string((int) type.getMaybe()) + " aka " + type::defaultconversion::string::Maybe2String.at(type.getMaybe()), type.getPath());
throw error::ValueNotValidException(
__PRETTY_FUNCTION__,
"Somehow the maybe flag of a top level object declaration is set. This is not "
"valid!",
std::to_string((int)type.getMaybe()) + " aka " +
type::defaultconversion::string::Maybe2String.at(type.getMaybe()),
type.getPath());
}
}
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
ObjectClass::getCtorInitializers(const std::string& name) const
{
std::vector<std::pair<std::string, std::string>> ret;
bool any = false;
for (const auto& [key, child] : type.getDirectMemberTypes())
{
auto child_s = FromAronType(*child);
auto p = child_s->getCtorInitializers(key);
for (const auto& el : p.first)
{
ret.push_back(el);
}
any = any or p.second;
}
return {ret, any};
}
std::vector<std::string> ObjectClass::getRequiredIncludes() const
std::vector<std::string>
ObjectClass::getRequiredIncludes() const
{
std::vector<std::string> ret;
for (const auto& [key, child] : type.getDirectMemberTypes())
{
(void) key;
(void)key;
auto child_s = FromAronType(*child);
ret = simox::alg::appended(ret, child_s->getRequiredIncludes());
}
return ret;
}
std::vector<CppFieldPtr> ObjectClass::getPublicVariableDeclarations(const std::string&) const
std::vector<CppFieldPtr>
ObjectClass::getPublicVariableDeclarations(const std::string&) const
{
std::vector<CppFieldPtr> fields;
for (const auto& [key, member] : type.getDirectMemberTypes())
......@@ -68,7 +94,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return fields;
}
CppBlockPtr ObjectClass::getResetSoftBlock(const std::string& accessor) const
CppBlockPtr
ObjectClass::getResetSoftBlock(const std::string& accessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
if (type.getExtends() != nullptr)
......@@ -86,7 +113,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return block_if_data;
}
CppBlockPtr ObjectClass::getResetHardBlock(const std::string& accessor) const
CppBlockPtr
ObjectClass::getResetHardBlock(const std::string& accessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
if (type.getExtends() != nullptr)
......@@ -104,7 +132,11 @@ namespace armarx::aron::codegenerator::cpp::generator
return block_if_data;
}
CppBlockPtr ObjectClass::getWriteTypeBlock(const std::string&, const std::string&, const Path& p, std::string&) const
CppBlockPtr
ObjectClass::getWriteTypeBlock(const std::string&,
const std::string&,
const Path& p,
std::string&) const
{
static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
......@@ -116,10 +148,11 @@ namespace armarx::aron::codegenerator::cpp::generator
{
const auto extends_s = FromAronType(*type.getExtends());
b->addLine("// get base class of " + this->getFullInstantiatedCppTypename());
b->addLine("auto " + OBJECT_EXTENDS_ACCESSOR + " = " + extends_s->getFullInstantiatedCppTypename() + "::writeType(" +
ARON_WRITER_ACCESSOR + ", " +
"{" + simox::alg::join(type.getExtends()->getTemplateInstantiations(), ", ") + "}, " +
"::armarx::aron::type::Maybe::NONE);");
b->addLine("auto " + OBJECT_EXTENDS_ACCESSOR + " = " +
extends_s->getFullInstantiatedCppTypename() + "::writeType(" +
ARON_WRITER_ACCESSOR + ", " + "{" +
simox::alg::join(type.getExtends()->getTemplateInstantiations(), ", ") +
"}, " + "::armarx::aron::type::Maybe::NONE);");
}
else
{
......@@ -132,9 +165,11 @@ namespace armarx::aron::codegenerator::cpp::generator
const auto child_s = FromAronType(*child);
std::string child_return_variant;
Path nextPath = p.withElement(key, true);
CppBlockPtr child_b = child_s->getWriteTypeBlock(child_s->getFullInstantiatedCppTypename(), key, nextPath, child_return_variant);
CppBlockPtr child_b = child_s->getWriteTypeBlock(
child_s->getFullInstantiatedCppTypename(), key, nextPath, child_return_variant);
b->appendBlock(child_b);
b->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " + child_return_variant + ");");
b->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " +
child_return_variant + ");");
}
std::vector<std::string> templatesQuoted;
std::vector<std::string> templateIntantiationsQuoted;
......@@ -147,18 +182,19 @@ namespace armarx::aron::codegenerator::cpp::generator
templateIntantiationsQuoted.push_back("\"" + t + "\"");
}
b->addLine("return " + ARON_WRITER_ACCESSOR + ".writeObject(\"" + type.getObjectName() + "\", " +
"{" + simox::alg::join(templatesQuoted, ", ") + "}, " +
ARON_TEMPLATE_INSTANTIATIONS_ACCESSOR + ", " +
OBJECT_MEMBERS_ACCESSOR + ", " +
OBJECT_EXTENDS_ACCESSOR + ", " +
ARON_MAYBE_TYPE_ACCESSOR + ", " +
ARON_PATH_ACCESSOR + "); // of top level object " + getInstantiatedCppTypename());;
b->addLine("return " + ARON_WRITER_ACCESSOR + ".writeObject(\"" + type.getObjectName() +
"\", " + "{" + simox::alg::join(templatesQuoted, ", ") + "}, " +
ARON_TEMPLATE_INSTANTIATIONS_ACCESSOR + ", " + OBJECT_MEMBERS_ACCESSOR + ", " +
OBJECT_EXTENDS_ACCESSOR + ", " + ARON_MAYBE_TYPE_ACCESSOR + ", " +
ARON_PATH_ACCESSOR + "); // of top level object " +
getInstantiatedCppTypename());
;
return b;
}
CppBlockPtr ObjectClass::getWriteBlock(const std::string&, const Path& p, std::string&) const
CppBlockPtr
ObjectClass::getWriteBlock(const std::string&, const Path& p, std::string&) const
{
static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
......@@ -171,8 +207,11 @@ namespace armarx::aron::codegenerator::cpp::generator
if (type.getExtends() != nullptr)
{
const auto extends_s = FromAronType(*type.getExtends());
block_if_data->addLine("// write base class of " + this->getFullInstantiatedCppTypename());
block_if_data->addLine(OBJECT_EXTENDS_ACCESSOR + " = " + extends_s->getFullInstantiatedCppTypename() + "::write(" + ARON_WRITER_ACCESSOR + ");");
block_if_data->addLine("// write base class of " +
this->getFullInstantiatedCppTypename());
block_if_data->addLine(OBJECT_EXTENDS_ACCESSOR + " = " +
extends_s->getFullInstantiatedCppTypename() + "::write(" +
ARON_WRITER_ACCESSOR + ");");
}
block_if_data->addLine("// members of " + this->getFullInstantiatedCppTypename());
......@@ -183,51 +222,67 @@ namespace armarx::aron::codegenerator::cpp::generator
Path nextPath = p.withElement(key, true);
CppBlockPtr child_b = child_s->getWriteBlock(key, nextPath, child_return_variant);
block_if_data->addLine("auto " + child_return_variant + " = " + ARON_WRITER_ACCESSOR + ".writeNull();");
block_if_data->addLine("auto " + child_return_variant + " = " + ARON_WRITER_ACCESSOR +
".writeNull();");
block_if_data->appendBlock(child_b);
block_if_data->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " + child_return_variant + ");");
block_if_data->addLine(OBJECT_MEMBERS_ACCESSOR + ".emplace(\"" + key + "\", " +
child_return_variant + ");");
}
block_if_data->addLine("return " + ARON_WRITER_ACCESSOR + ".writeDict("+OBJECT_MEMBERS_ACCESSOR+", " +
OBJECT_EXTENDS_ACCESSOR + ", "+
ARON_PATH_ACCESSOR + "); // of top level object " + getInstantiatedCppTypename());
block_if_data->addLine("return " + ARON_WRITER_ACCESSOR + ".writeDict(" +
OBJECT_MEMBERS_ACCESSOR + ", " + OBJECT_EXTENDS_ACCESSOR + ", " +
ARON_PATH_ACCESSOR + "); // of top level object " +
getInstantiatedCppTypename());
return block_if_data;
}
CppBlockPtr ObjectClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
CppBlockPtr
ObjectClass::getReadBlock(const std::string&, const std::string& variantAccessor) const
{
static const std::string OBJECT_MEMBERS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectMembers";
static const std::string OBJECT_EXTENDS_ACCESSOR = ARON_VARIABLE_PREFIX + "_objectExtends";
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("std::map<std::string, _Aron_TNonConst> " + OBJECT_MEMBERS_ACCESSOR + ";");
block_if_data->addLine("std::map<std::string, _Aron_TNonConst> " + OBJECT_MEMBERS_ACCESSOR +
";");
if (type.getExtends() != nullptr)
{
const auto extends_s = FromAronType(*type.getExtends());
block_if_data->addLine(extends_s->getFullInstantiatedCppTypename() + "::read(" + ARON_READER_ACCESSOR + ", "+variantAccessor+");");
block_if_data->addLine(extends_s->getFullInstantiatedCppTypename() + "::read(" +
ARON_READER_ACCESSOR + ", " + variantAccessor + ");");
}
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readDict("+variantAccessor+", "+OBJECT_MEMBERS_ACCESSOR+"); // of top level object " + getInstantiatedCppTypename());
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readDict(" + variantAccessor + ", " +
OBJECT_MEMBERS_ACCESSOR + "); // of top level object " +
getInstantiatedCppTypename());
for (const auto& [key, child] : type.getDirectMemberTypes())
{
const auto child_s = FromAronType(*child);
std::string child_accessor = OBJECT_MEMBERS_ACCESSOR + "_" + key + "_iterator";
block_if_data->addLine("auto " + child_accessor + " = " + OBJECT_MEMBERS_ACCESSOR + ".find(\"" + key + "\");");
block_if_data->addLine("ARMARX_CHECK_AND_THROW(" + child_accessor + " != " + OBJECT_MEMBERS_ACCESSOR + ".end(), ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Missing member '" + key + "' in aron object '" + getFullClassCppTypename() + "'.\"));");
block_if_data->addLine("auto " + child_accessor + " = " + OBJECT_MEMBERS_ACCESSOR +
".find(\"" + key + "\");");
block_if_data->addLine(
"ARMARX_CHECK_AND_THROW(" + child_accessor + " != " + OBJECT_MEMBERS_ACCESSOR +
".end(), ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Missing "
"member '" +
key + "' in aron object '" + getFullClassCppTypename() + "'.\"));");
block_if_data->appendBlock(child_s->getReadBlock(key, child_accessor + "->second"));
}
return block_if_data;
}
CppBlockPtr ObjectClass::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
CppBlockPtr
ObjectClass::getEqualsBlock(const std::string& accessor,
const std::string& otherInstanceAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
if (type.getExtends() != nullptr)
{
const auto extends_s = FromAronType(*type.getExtends());
block_if_data->addLine("if (not (" + extends_s->getFullInstantiatedCppTypename() + "::operator== (" + otherInstanceAccessor + ")))");
block_if_data->addLine("if (not (" + extends_s->getFullInstantiatedCppTypename() +
"::operator== (" + otherInstanceAccessor + ")))");
block_if_data->addLineAsBlock("return false;");
}
for (const auto& [key, child] : type.getDirectMemberTypes())
......@@ -239,7 +294,8 @@ namespace armarx::aron::codegenerator::cpp::generator
return block_if_data;
}
std::pair<std::vector<std::pair<std::string, std::string>>, bool> ObjectClass::getCopyCtorInitializers(const std::string&) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
ObjectClass::getCopyCtorInitializers(const std::string&) const
{
std::vector<std::pair<std::string, std::string>> ret;
......@@ -259,4 +315,4 @@ namespace armarx::aron::codegenerator::cpp::generator
}
return {ret, anyComplex};
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/toplevel/ObjectClass.h
View file @ 4ee3e4f3
......@@ -26,11 +26,9 @@
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/SpecializedGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/container/Object.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class ObjectClass :
public detail::SpecializedGeneratorBase<type::Object, ObjectClass>
class ObjectClass : public detail::SpecializedGeneratorBase<type::Object, ObjectClass>
{
public:
// constructors
......@@ -41,13 +39,20 @@ namespace armarx::aron::codegenerator::cpp::generator
std::vector<std::string> getRequiredIncludes() const final;
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;
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(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;
CppBlockPtr getWriteBlock(const std::string& cppAccessor, const Path&, std::string&) const final;
CppBlockPtr getWriteTypeBlock(const std::string& typeAccessor,
const std::string& cppAccessor,
const Path&,
std::string& variantAccessor) const final;
CppBlockPtr
getWriteBlock(const std::string& cppAccessor, const Path&, std::string&) const final;
CppBlockPtr getReadBlock(const std::string& cppAccessor, const std::string&) const final;
CppBlockPtr getEqualsBlock(const std::string&, const std::string&) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/test/aron/OptionalTest.xml
View file @ 4ee3e4f3
......@@ -47,7 +47,7 @@
</ObjectChild>
<ObjectChild key='some_eigen_matrix'>
<Matrix rows="25" cols="10" type="int64" optional="true"/>
<Matrix rows="25" cols="10" type="int64" />
</ObjectChild>
<ObjectChild key='some_obj'>
......@@ -63,7 +63,7 @@
</ObjectChild>
<ObjectChild key="an_optional_pose">
<Pose />
<Pose optional="true"/>
</ObjectChild>
</Object>
......
source/RobotAPI/libraries/aron/codegeneration/test/aron/PrimitiveTest.xml
View file @ 4ee3e4f3
......@@ -4,22 +4,22 @@
<GenerateTypes>
<Object name='armarx::PrimitiveTest'>
<objectchild key='the_int'>
<int />
<int default="45"/>
</ObjectChild>
<objectchild key='the_long'>
<long />
<long default="44"/>
</ObjectChild>
<objectchild key='the_float'>
<float />
<float default="43"/>
</ObjectChild>
<objectchild key='the_double'>
<double />
<double default="42"/>
</ObjectChild>
<objectchild key='the_string'>
<string />
<string default="lalala" />
</ObjectChild>
<objectchild key='the_bool'>
<bool />
<bool default="true"/>
</ObjectChild>
</Object>
</GenerateTypes>
......