Skip to content
Snippets Groups Projects
Commit 4ac4013a authored by Fabian Tërnava's avatar Fabian Tërnava
Browse files

Merge branch 'aron/dev' into 'master' 

Aron defaults

See merge request !350
parents a92df880 23d86826
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1127 additions and 490 deletions
source/RobotAPI/components/armem/server/ExampleMemory/aron/ExampleData.xml
+ 3
− 3
View file @ 4ac4013a
......@@ -20,13 +20,13 @@ An example data containing different native ARON types.
<GenerateTypes>
<Object name='armarx::armem::example::InnerClass'>
<ObjectChild key='element_int'>
<Int />
<int32 default="42" />
</ObjectChild>
<ObjectChild key='element_float'>
<Float />
<float32 default="666.66" />
</ObjectChild>
<ObjectChild key='element_string'>
<String />
<String default="foobar" />
</ObjectChild>
</Object>
......
source/RobotAPI/interface/aron/Aron.ice
+ 217
− 37
View file @ 4ac4013a
......@@ -4,23 +4,27 @@
* Changelog:
* - Update 1.1.0: Allow templates in aron and anyobjects
* - Update 1.1.1: Switch to armarx type. Also remove position, orientation and pose types as they are nothing else that matrices or quaternions
* - Update 2.0.0: Add support for aron defaults. Also add marshalling checks in aron variants.
**/
#include <ArmarXCore/interface/core/BasicTypes.ice>
#define ARON_MAJOR "1"
#define ARON_MINOR "1"
#define ARON_PATCH "2"
#define ARON_VERSION "1.1.2"
// Those macros stay defined
#define ARON_MAJOR "2" // ice interface changes
#define ARON_MINOR "0" // aron header changes
#define ARON_PATCH "0" // aron cpp changes
#define ARON_VERSION "2.0.0"
module armarx
{
module aron
{
// also make version number available to other languages without a preprocessor
const string MAJOR = ARON_MAJOR;
const string MINOR = ARON_MINOR;
const string PATCH = ARON_PATCH;
const string VERSION = ARON_VERSION;
/*************************
* Aron Types ************
************************/
......@@ -48,6 +52,13 @@ module armarx
FLOAT32,
FLOAT64
};
module default_value
{
const string ONES = "1";
const string ZEROS = "0";
const string DEFAULT = "";
}
};
module image
......@@ -57,6 +68,14 @@ module armarx
RGB24,
DEPTH32
};
module default_value
{
const string IDENTITY = "identity";
const string ONES = "1";
const string ZEROS = "0";
const string DEFAULT = "";
}
};
module pointcloud
......@@ -71,6 +90,14 @@ module armarx
POINT_XYZRGBA,
POINT_XYZHSV
};
module default_value
{
const string IDENTITY = "identity";
const string ONES = "1";
const string ZEROS = "0";
const string DEFAULT = "";
}
};
module matrix
......@@ -83,6 +110,14 @@ module armarx
FLOAT32,
FLOAT64
};
module default_value
{
const string IDENTITY = "identity";
const string ONES = "1";
const string ZEROS = "0";
const string DEFAULT = "";
}
};
module quaternion
......@@ -92,46 +127,154 @@ module armarx
FLOAT32,
FLOAT64
};
module default_value
{
const string ONES = "1";
const string ZEROS = "0";
const string DEFAULT = "";
}
};
module aron_enum
{
module default_value
{
const string DEFAULT = "";
}
}
module dto
{
class GenericType {
class GenericType
{
string VERSION = ARON_VERSION;
Maybe maybe = Maybe::NONE;
}
};
sequence<GenericType> GenericTypeSeq;
dictionary<string, GenericType> GenericTypeDict;
/* ***** Container types ***** */
class List extends GenericType { GenericType acceptedType; }
class Tuple extends GenericType { GenericTypeSeq elementTypes; }
class Pair extends GenericType { GenericType acceptedType1; GenericType acceptedType2; }
class AronObject extends GenericType { AronObject parent; Ice::StringSeq templates; string objectName; Ice::StringSeq templateInstantiations; GenericTypeDict elementTypes; }
class Dict extends GenericType { GenericType acceptedType; }
class List extends GenericType
{
GenericType acceptedType;
};
class Tuple extends GenericType
{
GenericTypeSeq elementTypes;
};
class Pair extends GenericType
{
GenericType acceptedType1;
GenericType acceptedType2;
};
class AronObject extends GenericType
{
Ice::StringSeq templates;
string objectName;
AronObject parent;
Ice::StringSeq templateInstantiations;
GenericTypeDict elementTypes;
};
class Dict extends GenericType
{
GenericType acceptedType;
}
/* ***** Complex Types (serialize to ndarray) ***** */
class NDArray extends GenericType { int ndimensions; ndarray::ElementType elementType; }
class Matrix extends GenericType { int rows; int cols; matrix::ElementType elementType; }
class Quaternion extends GenericType { quaternion::ElementType elementType; }
class Image extends GenericType { image::PixelType pixelType; }
class PointCloud extends GenericType { pointcloud::VoxelType voxelType; }
class NDArray extends GenericType
{
int ndimensions;
ndarray::ElementType elementType;
string defaultValue = type::ndarray::default_value::DEFAULT;
// ONES_DEFAULT_VALUE | ZEROS_DEFAULT_VALUE | <value> | ""
};
class Matrix extends GenericType
{
int rows;
int cols;
matrix::ElementType elementType;
string defaultValue = type::matrix::default_value::DEFAULT;
// IDENTITY_DEFAULT_VALUE (if quadratic) | ONES_DEFAULT_VALUE | ZEROS_DEFAULT_VALUE | <value> | ""
};
class Quaternion extends GenericType
{
quaternion::ElementType elementType;
string defaultValue = type::quaternion::default_value::DEFAULT;
// ONES_DEFAULT_VALUE | ZEROS_DEFAULT_VALUE | <value sequence> | ""
};
class Image extends GenericType
{
image::PixelType pixelType;
string defaultValue = type::image::default_value::DEFAULT;
// IDENTITY_DEFAULT_VALUE (if quadratic) | ONES_DEFAULT_VALUE | ZEROS_DEFAULT_VALUE | <value> | ""
};
class PointCloud extends GenericType
{
pointcloud::VoxelType voxelType;
string defaultValue = type::pointcloud::default_value::DEFAULT;
// IDENTITY_DEFAULT_VALUE (if quadratic) | ONES_DEFAULT_VALUE | ZEROS_DEFAULT_VALUE | <value> | ""
};
/* ***** Enum types ***** */
class IntEnum extends GenericType { string enumName; StringIntDict acceptedValues; }
class IntEnum extends GenericType
{
string enumName;
StringIntDict acceptedValues;
string defaultValue = aron_enum::default_value::DEFAULT;
// in acceptedValues.keys | ""
};
//class FloatEnum extends GenericType { string enumName; StringFloatDict acceptedValues; }
//class StringEnum extends GenericType { string enumName; StringStringDict acceptedValues; }
/* ***** Any Types ***** */
class AnyObject extends GenericType { };
class AnyObject extends GenericType
{
};
/* ***** Primitive Types ***** */
class AronInt extends GenericType { };
class AronLong extends GenericType { };
class AronDouble extends GenericType { };
class AronFloat extends GenericType { };
class AronString extends GenericType { };
class AronBool extends GenericType { };
class AronInt extends GenericType
{
int defaultValue = 0; // <value>
};
class AronLong extends GenericType
{
long defaultValue = 0; // <value>
};
class AronDouble extends GenericType
{
double defaultValue = 0; // <value>
};
class AronFloat extends GenericType
{
float defaultValue = 0; // <value>
};
class AronString extends GenericType
{
string defaultValue = ""; // <value>
};
class AronBool extends GenericType
{
bool defaultValue = false; // <value>
};
};
};
......@@ -143,30 +286,67 @@ module armarx
{
module dto
{
class GenericData {
class GenericData
{
string VERSION = ARON_VERSION;
};
sequence<GenericData> GenericDataSeq;
dictionary<string, GenericData> GenericDataDict;
/* ***** Container Data ***** */
class List extends GenericData { GenericDataSeq elements; };
class Dict extends GenericData { GenericDataDict elements; };
class List extends GenericData
{
GenericDataSeq elements;
};
class Dict extends GenericData
{
GenericDataDict elements;
};
/* ***** Complex Data ***** */
// The NDArray contains more or less the same information as an AronType, but there is no other way to do it
// Especially, note the difference between the type's typeName (e.g. "GRAY_SCALE_IMAGE" => language dependent) and the data's type ("0")
// Further, note the difference between the type's dimensions (e.g. 128x128) and the data's dimensions (128x128x3 for RGB)
class NDArray extends GenericData { Ice::IntSeq shape; string type; Ice::ByteSeq data; }
class NDArray extends GenericData
{
Ice::IntSeq shape;
string type;
Ice::ByteSeq data;
};
/* ***** Primitive Data ***** */
class AronInt extends GenericData { int value; };
class AronLong extends GenericData { long value; };
class AronDouble extends GenericData { double value; };
class AronFloat extends GenericData { float value; };
class AronString extends GenericData { string value; };
class AronBool extends GenericData { bool value; };
// They must be prefixed with 'Aron' as e.g. Int cannot be used as class name
class AronInt extends GenericData
{
int value;
};
class AronLong extends GenericData
{
long value;
};
class AronDouble extends GenericData
{
double value;
};
class AronFloat extends GenericData
{
float value;
};
class AronString extends GenericData
{
string value;
};
class AronBool extends GenericData
{
bool value;
};
// useful for memory ice_conversions
sequence<Dict> AronDictSeq;
......
source/RobotAPI/libraries/armem_gui/test/ArMemGuiTest.cpp
+ 15
− 11
View file @ 4ac4013a
......@@ -36,14 +36,14 @@
namespace dn = armarx::aron::data;
namespace tn = armarx::aron::type;
namespace ArMemGuiTest
{
struct Fixture
{
};
void test_sanitize(const std::string& in, const std::string& expected)
void
test_sanitize(const std::string& in, const std::string& expected)
{
const std::string out = armarx::armem::gui::instance::sanitizeTypeName(in);
BOOST_TEST_CONTEXT("in = '" << in << "'")
......@@ -51,13 +51,11 @@ namespace ArMemGuiTest
BOOST_CHECK_EQUAL(out, expected);
}
}
}
} // namespace ArMemGuiTest
BOOST_FIXTURE_TEST_SUITE(ArMemGuiTest, ArMemGuiTest::Fixture)
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_int)
{
test_sanitize(tn::Int().getFullName(), "Int");
......@@ -72,7 +70,8 @@ BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_float)
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_dict)
{
tn::Dict dict(std::make_shared<tn::Float>());
tn::Dict dict;
dict.setAcceptedType(std::make_shared<tn::Float>());
test_sanitize(dict.getFullName(), "Dict<Float>");
test_sanitize(dn::Dict().getFullName(), "Dict");
......@@ -80,7 +79,8 @@ BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_dict)
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_list)
{
tn::List list(std::make_shared<tn::Long>());
tn::List list;
list.setAcceptedType(std::make_shared<tn::Long>());
test_sanitize(list.getFullName(), "List<Long>");
test_sanitize(dn::List().getFullName(), "List");
......@@ -88,20 +88,24 @@ BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_list)
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_object)
{
tn::Object obj("namespace::MyObjectName");
tn::Object obj;
obj.setObjectName("namespace::MyObjectName");
test_sanitize(obj.getFullName(), "MyObjectName (namespace)");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_tuple)
{
std::vector<tn::VariantPtr> ac = {std::make_shared<tn::Int>(), std::make_shared<tn::Float>()};
tn::Tuple type(ac);
tn::Tuple type;
type.setAcceptedTypes(ac);
test_sanitize(type.getFullName(), "Tuple<Int, Float>");
}
BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_pair)
{
tn::Pair type(std::make_shared<tn::Int>(), std::make_shared<tn::Float>());
tn::Pair type;
type.setFirstAcceptedType(std::make_shared<tn::Int>());
type.setSecondAcceptedType(std::make_shared<tn::Float>());
test_sanitize(type.getFullName(), "Pair<Int, Float>");
}
......@@ -115,7 +119,7 @@ BOOST_AUTO_TEST_CASE(test_sanitizeTypeName_ndarry)
}
{
dn::NDArray data;
data.setShape({ 3, 2, 1});
data.setShape({3, 2, 1});
test_sanitize(data.getFullName(), "NDArray<3, 2, 1, >");
}
}
......
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/enum/IntEnum.cpp
+ 35
− 15
View file @ 4ac4013a
......@@ -26,7 +26,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
// constructors
......@@ -35,18 +34,27 @@ namespace armarx::aron::codegenerator::cpp::generator
e.getEnumName(),
e.getEnumName(),
simox::meta::get_type_name<data::dto::NDArray>(),
simox::meta::get_type_name<type::dto::IntEnum>(), e)
simox::meta::get_type_name<type::dto::IntEnum>(),
e)
{
}
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
IntEnum::getCtorInitializers(const std::string& name) const
{
return {{{name, type.getDefaultValueName()}}, true};
}
CppBlockPtr IntEnum::getResetSoftBlock(const std::string& accessor) const
CppBlockPtr
IntEnum::getResetSoftBlock(const std::string& accessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(accessor + nextEl() + "resetSoft();");
return this->resolveMaybeResetSoftBlock(block_if_data, accessor);
}
CppBlockPtr IntEnum::getResetHardBlock(const std::string& accessor) const
CppBlockPtr
IntEnum::getResetHardBlock(const std::string& accessor) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
if (type.getMaybe() != type::Maybe::NONE)
......@@ -60,39 +68,51 @@ namespace armarx::aron::codegenerator::cpp::generator
return this->resolveMaybeResetHardBlock(b, accessor);
}
CppBlockPtr IntEnum::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
IntEnum::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+" = " +getInstantiatedCppTypename() + "::writeType(" + ARON_WRITER_ACCESSOR + ", " +
"{}, " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " +
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + cppAccessor);
b->addLine("auto " + variantAccessor + " = " + getInstantiatedCppTypename() +
"::writeType(" + ARON_WRITER_ACCESSOR + ", " + "{}, " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return b;
}
CppBlockPtr IntEnum::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
IntEnum::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+" = " + cppAccessor + nextEl() + "write(" + ARON_WRITER_ACCESSOR + ", "+
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {"+simox::alg::join(p.getPath(), ", ")+"})); // of " + cppAccessor);
block_if_data->addLine(variantAccessor + " = " + cppAccessor + nextEl() + "write(" +
ARON_WRITER_ACCESSOR + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return resolveMaybeWriteBlock(block_if_data, cppAccessor);
}
CppBlockPtr IntEnum::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
CppBlockPtr
IntEnum::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
if (const auto reset = resolveMaybeGeneratorWithSetter(cppAccessor); !reset.empty())
{
block_if_data->addLine(reset);
}
block_if_data->addLine(cppAccessor + nextEl() + "read(" + ARON_READER_ACCESSOR + ", " + variantAccessor + ");");
block_if_data->addLine(cppAccessor + nextEl() + "read(" + ARON_READER_ACCESSOR + ", " +
variantAccessor + ");");
return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/enum/IntEnum.h
+ 15
− 9
View file @ 4ac4013a
......@@ -23,20 +23,18 @@
#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 <string>
#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 IntEnum;
typedef std::shared_ptr<IntEnum> IntEnumSerializerPtr;
class IntEnum :
public detail::SpecializedGeneratorBase<type::IntEnum, IntEnum>
class IntEnum : public detail::SpecializedGeneratorBase<type::IntEnum, IntEnum>
{
public:
// constructors
......@@ -44,10 +42,18 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~IntEnum() = default;
// virtual implementations
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
getCtorInitializers(const std::string& name) 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& 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;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Image.cpp
+ 69
− 40
View file @ 4ac4013a
......@@ -26,79 +26,103 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
const std::map<type::image::PixelType, std::tuple<std::string, int, std::string>> PixelType2Cpp =
{
{ type::image::PixelType::RGB24, {"CV_8UC3", 3, "::armarx::aron::type::image::PixelType::RGB24"}},
{ type::image::PixelType::DEPTH32, {"CV_32FC1", 4, "::armarx::aron::type::image::PixelType::DEPTH32"}},
const std::map<type::image::PixelType, std::tuple<std::string, int, std::string>>
PixelType2Cpp = {
{type::image::PixelType::RGB24,
{"CV_8UC3", 3, "::armarx::aron::type::image::PixelType::RGB24"}},
{type::image::PixelType::DEPTH32,
{"CV_32FC1", 4, "::armarx::aron::type::image::PixelType::DEPTH32"}},
};
// constructors
Image::Image(const type::Image& n) :
detail::NDArrayGenerator<type::Image, Image>(
"cv::Mat",
"cv::Mat",
simox::meta::get_type_name<data::dto::NDArray>(),
simox::meta::get_type_name<type::dto::Image>(), n)
simox::meta::get_type_name<type::dto::Image>(),
n)
{
}
std::vector<std::string> Image::getRequiredIncludes() const
std::vector<std::string>
Image::getRequiredIncludes() const
{
return {"<opencv2/core/core.hpp>"};
}
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Image::getCtorInitializers(const std::string&) const
{
// TODO
return {{}, false};
}
CppBlockPtr Image::getResetHardBlock(const std::string& cppAccessor) const
CppBlockPtr
Image::getResetHardBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = detail::NDArrayGenerator<type::Image, Image>::getResetHardBlock(cppAccessor);
block_if_data->addLine(cppAccessor + ".create(0, 0, " + std::get<0>(PixelType2Cpp.at(type.getPixelType())) + ");");
CppBlockPtr block_if_data =
detail::NDArrayGenerator<type::Image, Image>::getResetHardBlock(cppAccessor);
block_if_data->addLine(cppAccessor + ".create(0, 0, " +
std::get<0>(PixelType2Cpp.at(type.getPixelType())) + ");");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
CppBlockPtr Image::getResetSoftBlock(const std::string& cppAccessor) const
CppBlockPtr
Image::getResetSoftBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + ".create(0, 0, " + std::get<0>(PixelType2Cpp.at(type.getPixelType())) + ");");
block_if_data->addLine(cppAccessor + ".create(0, 0, " +
std::get<0>(PixelType2Cpp.at(type.getPixelType())) + ");");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
CppBlockPtr Image::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
Image::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 + ".writeImage(" + std::get<2>(PixelType2Cpp.at(type.getPixelType())) + ", " +
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 + ".writeImage(" +
std::get<2>(PixelType2Cpp.at(type.getPixelType())) + ", " + "\"" +
type.getDefaultValue() + "\", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return b;
}
CppBlockPtr Image::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
Image::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;
const std::string shape_vec = ARON_VARIABLE_PREFIX + "_" + escaped_accessor + "_imageShape";
block_if_data->addLine("std::vector<int> " + shape_vec + "(" + cppAccessor + nextEl() + "size.p, " + cppAccessor + nextEl() + "size.p + " + cppAccessor + nextEl() + "dims);");
block_if_data->addLine(shape_vec+".push_back(" + cppAccessor + nextEl() + "elemSize());");
block_if_data->addLine(variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeNDArray(" + shape_vec + ", "+
"std::to_string(" + cppAccessor + nextEl() + "type()), "+
"reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "data), "+
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {" + simox::alg::join(p.getPath(), ", ") + "})); // of " + cppAccessor);
block_if_data->addLine("std::vector<int> " + shape_vec + "(" + cppAccessor + nextEl() +
"size.p, " + cppAccessor + nextEl() + "size.p + " + cppAccessor +
nextEl() + "dims);");
block_if_data->addLine(shape_vec + ".push_back(" + cppAccessor + nextEl() + "elemSize());");
block_if_data->addLine(variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeNDArray(" +
shape_vec + ", " + "std::to_string(" + cppAccessor + nextEl() +
"type()), " + "reinterpret_cast<const unsigned char*>(" +
cppAccessor + nextEl() + "data), " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return resolveMaybeWriteBlock(block_if_data, cppAccessor);
}
CppBlockPtr Image::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
CppBlockPtr
Image::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(cppAccessor);
......@@ -109,23 +133,28 @@ 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(cppAccessor + " = " + getInstantiatedCppTypename() + "(std::vector<int>({" + dims + ".begin(), std::prev(" + dims + ".end())}), std::stoi(" + type + "));");
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "data), "+data+".data(), "+data+".size());");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readNDArray(" + variantAccessor +
", " + dims + ", " + type + ", " + data + "); // of " + cppAccessor);
block_if_data->addLine(cppAccessor + " = " + getInstantiatedCppTypename() +
"(std::vector<int>({" + dims + ".begin(), std::prev(" + dims +
".end())}), std::stoi(" + type + "));");
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor +
nextEl() + "data), " + data + ".data(), " + data + ".size());");
return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
}
CppBlockPtr Image::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
CppBlockPtr
Image::getEqualsBlock(const std::string& accessor,
const std::string& otherInstanceAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
std::string resolved_accessor = this->resolveMaybeAccessor(accessor);
std::string other_instance_resolved_accessor = this->resolveMaybeAccessor(otherInstanceAccessor);
std::string other_instance_resolved_accessor =
this->resolveMaybeAccessor(otherInstanceAccessor);
block_if_data->addLine("if (cv::countNonZero(" + resolved_accessor + " != " + other_instance_resolved_accessor + ") != 0)");
block_if_data->addLine("if (cv::countNonZero(" + resolved_accessor +
" != " + other_instance_resolved_accessor + ") != 0)");
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/Image.h
+ 15
− 11
View file @ 4ac4013a
......@@ -23,33 +23,37 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h>
#include <map>
#include <memory>
#include <string>
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Image.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Image :
public detail::NDArrayGenerator<type::Image, Image>
class Image : public detail::NDArrayGenerator<type::Image, Image>
{
public:
Image(const type::Image& n);
virtual ~Image() = default;
// 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 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;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Matrix.cpp
+ 34
− 7
View file @ 4ac4013a
......@@ -58,6 +58,33 @@ namespace armarx::aron::codegenerator::cpp::generator
return {"<Eigen/Core>"};
}
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
Matrix::getCtorInitializers(const std::string& name) const
{
if (type.getDefaultValue() == aron::type::matrix::default_value::DEFAULT)
{
return {{}, false};
}
if (type.getDefaultValue() == aron::type::matrix::default_value::IDENTITY)
{
return {{{name, getInstantiatedCppTypename() + "::Identity()"}}, true};
}
if (type.getDefaultValue() == aron::type::matrix::default_value::ZEROS)
{
return {{{name, getInstantiatedCppTypename() + "::Zero()"}}, true};
}
if (type.getDefaultValue() == aron::type::matrix::default_value::ONES)
{
return {{{name, getInstantiatedCppTypename() + "::One()"}}, true};
}
else
{
// try to parse num. We ensure from typereader that defaultValue is valid number
return {{{name, getInstantiatedCppTypename() + "::One() * " + type.getDefaultValue()}},
true};
}
}
CppBlockPtr
Matrix::getResetSoftBlock(const std::string& cppAccessor) const
{
......@@ -75,13 +102,13 @@ namespace armarx::aron::codegenerator::cpp::generator
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 +
".writeMatrix((int) " + std::to_string(type.getRows()) + ", " + "(int) " +
std::to_string(type.getCols()) + ", " +
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 + ".writeMatrix((int) " +
std::to_string(type.getRows()) + ", " + "(int) " + std::to_string(type.getCols()) +
", " + 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;
}
......
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Matrix.h
+ 15
− 9
View file @ 4ac4013a
......@@ -23,17 +23,15 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h>
#include <map>
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/Matrix.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class Matrix :
public detail::NDArrayGenerator<type::Matrix, Matrix>
class Matrix : public detail::NDArrayGenerator<type::Matrix, Matrix>
{
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/ndarray/NDArray.cpp
+ 22
− 9
View file @ 4ac4013a
......@@ -26,7 +26,6 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
// constructors
......@@ -35,33 +34,47 @@ namespace armarx::aron::codegenerator::cpp::generator
"NDArray",
"NDArray",
simox::meta::get_type_name<data::dto::NDArray>(),
simox::meta::get_type_name<type::dto::NDArray>(), n)
simox::meta::get_type_name<type::dto::NDArray>(),
n)
{
}
CppBlockPtr NDArray::getResetSoftBlock(const std::string& cppAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
NDArray::getCtorInitializers(const std::string&) const
{
return {{}, false};
}
CppBlockPtr
NDArray::getResetSoftBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = " + this->getFullInstantiatedCppTypename() + "();");
block_if_data->addLine(cppAccessor + " = " + this->getFullInstantiatedCppTypename() +
"();");
return resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
CppBlockPtr NDArray::getWriteTypeBlock(const std::string&, const std::string&, const Path& p, std::string&) const
CppBlockPtr
NDArray::getWriteTypeBlock(const std::string&,
const std::string&,
const Path& p,
std::string&) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
return b;
}
CppBlockPtr NDArray::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string&) const
CppBlockPtr
NDArray::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string&) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
return b;
}
CppBlockPtr NDArray::getReadBlock(const std::string& cppAccessor, const std::string&) const
CppBlockPtr
NDArray::getReadBlock(const std::string& cppAccessor, const std::string&) const
{
CppBlockPtr b = std::make_shared<CppBlock>();
return b;
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/NDArray.h
+ 15
− 9
View file @ 4ac4013a
......@@ -23,16 +23,14 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h>
#include <string>
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/NDArray.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class NDArray :
public detail::NDArrayGenerator<type::NDArray, NDArray>
class NDArray : public detail::NDArrayGenerator<type::NDArray, NDArray>
{
public:
......@@ -41,9 +39,17 @@ namespace armarx::aron::codegenerator::cpp::generator
virtual ~NDArray() = default;
// virtual implementations
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;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.cpp
+ 88
− 35
View file @ 4ac4013a
......@@ -26,20 +26,31 @@
#include <SimoxUtility/meta/type_name.h>
namespace armarx::aron::codegenerator::cpp::generator
{
const std::map<type::pointcloud::VoxelType, std::tuple<std::string, int, std::string>> VoxelType2Cpp =
{
// see http://docs.ros.org/en/groovy/api/pcl/html/point__types_8hpp_source.html
{type::pointcloud::VoxelType::POINT_XYZ, {"pcl::PointXYZ", 16, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZ"}},
{type::pointcloud::VoxelType::POINT_XYZI, {"pcl::PointXYZI", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZI"}},
{type::pointcloud::VoxelType::POINT_XYZL, {"pcl::PointXYZL", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZL"}},
{type::pointcloud::VoxelType::POINT_XYZRGB, {"pcl::PointXYZRGB", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGB"}},
{type::pointcloud::VoxelType::POINT_XYZRGBL, {"pcl::PointXYZRGBL", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGBL"}},
{type::pointcloud::VoxelType::POINT_XYZRGBA, {"pcl::PointXYZRGBA", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGBA"}},
{type::pointcloud::VoxelType::POINT_XYZHSV, {"pcl::PointXYZHSV", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZHSV"}}
};
const std::map<type::pointcloud::VoxelType, std::tuple<std::string, int, std::string>>
VoxelType2Cpp = {
// see http://docs.ros.org/en/groovy/api/pcl/html/point__types_8hpp_source.html
{type::pointcloud::VoxelType::POINT_XYZ,
{"pcl::PointXYZ", 16, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZ"}},
{type::pointcloud::VoxelType::POINT_XYZI,
{"pcl::PointXYZI", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZI"}},
{type::pointcloud::VoxelType::POINT_XYZL,
{"pcl::PointXYZL", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZL"}},
{type::pointcloud::VoxelType::POINT_XYZRGB,
{"pcl::PointXYZRGB", 32, "::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGB"}},
{type::pointcloud::VoxelType::POINT_XYZRGBL,
{"pcl::PointXYZRGBL",
32,
"::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGBL"}},
{type::pointcloud::VoxelType::POINT_XYZRGBA,
{"pcl::PointXYZRGBA",
32,
"::armarx::aron::type::pointcloud::VoxelType::POINT_XYZRGBA"}},
{type::pointcloud::VoxelType::POINT_XYZHSV,
{"pcl::PointXYZHSV",
32,
"::armarx::aron::type::pointcloud::VoxelType::POINT_XYZHSV"}}};
// constructors
PointCloud::PointCloud(const type::PointCloud& n) :
......@@ -52,45 +63,72 @@ namespace armarx::aron::codegenerator::cpp::generator
{
}
std::vector<std::string> PointCloud::getRequiredIncludes() const
std::vector<std::string>
PointCloud::getRequiredIncludes() const
{
return {"<pcl/point_cloud.h>", "<pcl/point_types.h>"};
}
CppBlockPtr PointCloud::getResetSoftBlock(const std::string& cppAccessor) const
std::pair<std::vector<std::pair<std::string, std::string>>, bool>
PointCloud::getCtorInitializers(const std::string&) const
{
// TODO
return {{}, false};
}
CppBlockPtr
PointCloud::getResetSoftBlock(const std::string& cppAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine(cppAccessor + " = " + getFullInstantiatedCppTypenameGenerator() + "(" + cppAccessor + nextEl() + "width, " + cppAccessor + nextEl() + "height);");
block_if_data->addLine(cppAccessor + " = " + getFullInstantiatedCppTypenameGenerator() +
"(" + cppAccessor + nextEl() + "width, " + cppAccessor + nextEl() +
"height);");
return this->resolveMaybeResetSoftBlock(block_if_data, cppAccessor);
}
CppBlockPtr PointCloud::getWriteTypeBlock(const std::string& typeAccessor, const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
PointCloud::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 + ".writePointCloud(" + std::get<2>(VoxelType2Cpp.at(type.getVoxelType())) + ", " +
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 + ".writePointCloud(" +
std::get<2>(VoxelType2Cpp.at(type.getVoxelType())) + ", " + "\"" +
type.getDefaultValue() + "\", " +
conversion::Maybe2CppString.at(type.getMaybe()) + ", " + "armarx::aron::Path(" +
ARON_PATH_ACCESSOR + ", {" + simox::alg::join(p.getPath(), ", ") +
"})); // of " + cppAccessor);
return b;
}
CppBlockPtr PointCloud::getWriteBlock(const std::string& cppAccessor, const Path& p, std::string& variantAccessor) const
CppBlockPtr
PointCloud::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({" + cppAccessor + nextEl() + "width, " + cppAccessor + nextEl() + "height, " + std::to_string(std::get<1>(VoxelType2Cpp.at(type.getVoxelType()))) + "}, "+
"\"" + std::get<0>(VoxelType2Cpp.at(type.getVoxelType())) + "\", "+
"reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() + "points.data()), "+
"armarx::aron::Path("+ARON_PATH_ACCESSOR+", {" + simox::alg::join(p.getPath(), ", ") + "})); // of " + cppAccessor);
block_if_data->addLine(
variantAccessor + " = " + ARON_WRITER_ACCESSOR + ".writeNDArray({" + cppAccessor +
nextEl() + "width, " + cppAccessor + nextEl() + "height, " +
std::to_string(std::get<1>(VoxelType2Cpp.at(type.getVoxelType()))) + "}, " + "\"" +
std::get<0>(VoxelType2Cpp.at(type.getVoxelType())) + "\", " +
"reinterpret_cast<const unsigned char*>(" + cppAccessor + nextEl() +
"points.data()), " + "armarx::aron::Path(" + ARON_PATH_ACCESSOR + ", {" +
simox::alg::join(p.getPath(), ", ") + "})); // of " + cppAccessor);
return resolveMaybeWriteBlock(block_if_data, cppAccessor);
}
CppBlockPtr PointCloud::getReadBlock(const std::string& cppAccessor, const std::string& variantAccessor) const
CppBlockPtr
PointCloud::getReadBlock(const std::string& cppAccessor,
const std::string& variantAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
std::string escaped_accessor = EscapeAccessor(cppAccessor);
......@@ -101,33 +139,48 @@ 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("ARMARX_CHECK_AND_THROW(" + dims + ".size() == 3, ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Received wrong dimensions for member '"+cppAccessor+"'.\"));");
block_if_data->addLine("ARMARX_CHECK_AND_THROW(" + type + " == \"" + std::get<0>(VoxelType2Cpp.at(this->type.getVoxelType())) + "\", ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Received wrong type for member '"+cppAccessor+"'.\"));");
block_if_data->addLine("" + ARON_READER_ACCESSOR + ".readNDArray(" + variantAccessor +
", " + dims + ", " + type + ", " + data + "); // of " + cppAccessor);
block_if_data->addLine(
"ARMARX_CHECK_AND_THROW(" + dims +
".size() == 3, ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, \"Received "
"wrong dimensions for member '" +
cppAccessor + "'.\"));");
block_if_data->addLine("ARMARX_CHECK_AND_THROW(" + type + " == \"" +
std::get<0>(VoxelType2Cpp.at(this->type.getVoxelType())) +
"\", ::armarx::aron::error::AronException(__PRETTY_FUNCTION__, "
"\"Received wrong type for member '" +
cppAccessor + "'.\"));");
// assign is not availablePCL for PCL 1.8
// block_if_data->addLine(cppAccessor + nextEl() + "assign(" + dims + "[0], " + dims + "[1], " + std::get<0>(VoxelType2Cpp.at(this->type.getVoxelType())) + "());");
block_if_data->addLine(cppAccessor + nextEl() + "clear();");
// resize(width, height , value) is not available either
// block_if_data->addLine(cppAccessor + nextEl() + "resize(" + dims + "[0], " + dims + "[1], " + std::get<0>(VoxelType2Cpp.at(this->type.getVoxelType())) + "()));");
block_if_data->addLine(cppAccessor + nextEl() + "resize(" + dims + "[0] * " + dims + "[1]);");
block_if_data->addLine(cppAccessor + nextEl() + "resize(" + dims + "[0] * " + dims +
"[1]);");
block_if_data->addLine(cppAccessor + nextEl() + "width = " + dims + "[0];");
block_if_data->addLine(cppAccessor + nextEl() + "height = " + dims + "[1];");
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor + nextEl() + "points.data()), "+data+".data(), "+data+".size());");
block_if_data->addLine("std::memcpy(reinterpret_cast<unsigned char*>(" + cppAccessor +
nextEl() + "points.data()), " + data + ".data(), " + data +
".size());");
return resolveMaybeReadBlock(block_if_data, cppAccessor, variantAccessor);
}
CppBlockPtr PointCloud::getEqualsBlock(const std::string& accessor, const std::string& otherInstanceAccessor) const
CppBlockPtr
PointCloud::getEqualsBlock(const std::string& accessor,
const std::string& otherInstanceAccessor) const
{
CppBlockPtr block_if_data = std::make_shared<CppBlock>();
block_if_data->addLine("if (" + accessor + nextEl() + "width != " + otherInstanceAccessor + nextEl() + "width || " + accessor + nextEl() + "height != " + otherInstanceAccessor + nextEl() + "height)");
block_if_data->addLine("if (" + accessor + nextEl() + "width != " + otherInstanceAccessor +
nextEl() + "width || " + accessor + nextEl() +
"height != " + otherInstanceAccessor + nextEl() + "height)");
block_if_data->addLineAsBlock("return false;");
//block_if_data->addLine("if (" + accessor + nextEl() + "points != " + otherInstanceAccessor + nextEl() + "points)");
//block_if_data->addLine("\t return false;");
return resolveMaybeEqualsBlock(block_if_data, accessor, otherInstanceAccessor);
}
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/PointCloud.h
+ 15
− 9
View file @ 4ac4013a
......@@ -23,16 +23,14 @@
#pragma once
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h>
#include <map>
#include <RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/detail/NDArrayGenerator.h>
#include <RobotAPI/libraries/aron/core/type/variant/ndarray/PointCloud.h>
namespace armarx::aron::codegenerator::cpp::generator
{
class PointCloud :
public detail::NDArrayGenerator<type::PointCloud, PointCloud>
class PointCloud : public detail::NDArrayGenerator<type::PointCloud, PointCloud>
{
public:
// constructors
......@@ -41,10 +39,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& cppAccessor, const std::string&) const final;
};
}
} // namespace armarx::aron::codegenerator::cpp::generator
source/RobotAPI/libraries/aron/codegeneration/codegenerator/codewriter/cpp/generator/ndarray/Quaternion.cpp
+ 69
− 23
View file @ 4ac4013a
......@@ -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
+ 15
− 9
View file @ 4ac4013a
......@@ -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
+ 23
− 8
View file @ 4ac4013a
......@@ -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
+ 11
− 6
View file @ 4ac4013a
......@@ -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
+ 21
− 7
View file @ 4ac4013a
......@@ -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
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment