From 736b5df56cc257d3bbd9ba5d17aadb4e86bfbc12 Mon Sep 17 00:00:00 2001 From: Juan Lopez Fernandez Date: Tue, 14 May 2024 14:42:57 +0200 Subject: [PATCH 01/52] Add tree container Signed-off-by: Juan Lopez Fernandez --- src/cpp/utils/collections/Tree.hpp | 89 +++++++++++++++++ src/cpp/utils/collections/impl/Tree.ipp | 126 ++++++++++++++++++++++++ 2 files changed, 215 insertions(+) create mode 100644 src/cpp/utils/collections/Tree.hpp create mode 100644 src/cpp/utils/collections/impl/Tree.ipp diff --git a/src/cpp/utils/collections/Tree.hpp b/src/cpp/utils/collections/Tree.hpp new file mode 100644 index 00000000000..bb9f161b9e0 --- /dev/null +++ b/src/cpp/utils/collections/Tree.hpp @@ -0,0 +1,89 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @file Tree.hpp + * + */ + +#ifndef FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ +#define FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ + +#include + +namespace eprosima { +namespace utilities { +namespace collections { + +/** + * Generic data struct of with an internal value of type \c Info . + */ +template +struct Node +{ +public: + + Node(); + Node( + const Info& info); + Node( + Info&& info); + + template + Node( + Args... args); + + Info info; +}; + +/** + * Class that represents each of the Nodes that form a Tree, including the source and the leaves. + */ +template +class TreeNode : public Node +{ +public: + + using Node::Node; + + void add_branch( + const Info& info); + void add_branch( + Info&& info); + void add_branch( + const TreeNode& node); + void add_branch( + TreeNode&& node); + + bool leaf() const noexcept; + + unsigned int depth() const noexcept; + + const std::list& branches() const noexcept; + + std::list all_nodes() const noexcept; + +protected: + + std::list branches_; +}; + +} /* namespace collections */ +} /* namespace utilities */ +} /* namespace eprosima */ + +// Include implementation template file +#include "impl/Tree.ipp" + +#endif /* FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ */ diff --git a/src/cpp/utils/collections/impl/Tree.ipp b/src/cpp/utils/collections/impl/Tree.ipp new file mode 100644 index 00000000000..e0311be842f --- /dev/null +++ b/src/cpp/utils/collections/impl/Tree.ipp @@ -0,0 +1,126 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @file Tree.ipp + * + */ + +#ifndef SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ +#define SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ + +namespace eprosima { +namespace utilities { +namespace collections { + +template +Node::Node() +{ + // Do nothing +} + +template +Node::Node( + const Info& info) + : info(info) +{ + // Do nothing +} + +template +Node::Node( + Info&& info) + : info(std::move(info)) +{ + // Do nothing +} + +template +template +Node::Node( + Args... args) + : info(args ...) +{ + // Do nothing +} + +template +void TreeNode::add_branch( + const Info& info) +{ + branches_.push_back(TreeNode(info)); +} + +template +void TreeNode::add_branch( + Info&& info) +{ + branches_.push_back(TreeNode(std::move(info))); +} + +template +void TreeNode::add_branch( + const TreeNode& node) +{ + branches_.push_back(node); +} + +template +void TreeNode::add_branch( + TreeNode&& node) +{ + branches_.push_back(std::move(node)); +} + +template +bool TreeNode::leaf() const noexcept +{ + return branches_.empty(); +} + +template +unsigned int TreeNode::depth() const noexcept +{ + unsigned int max_value = 0; + for (const auto& b : branches_) + { + auto child_value = b.depth(); + max_value = MAX(max_value, child_value); + } + return max_value; +} + +template +const std::list>& TreeNode::branches() const noexcept +{ + return branches_; +} + +template +std::list> TreeNode::all_nodes() const noexcept +{ + std::list> result(branches_); + for (const auto& b : branches_) + { + auto b_branches = b.all_nodes(); + result.splice(result.begin(), b_branches); + } + return result; +} + +} /* namespace collections */ +} /* namespace utilities */ +} /* namespace eprosima */ + +#endif /* SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ */ From 20a1aac6740fbc1d48bd96439057ec1ffc2c5199 Mon Sep 17 00:00:00 2001 From: Juan Lopez Fernandez Date: Tue, 14 May 2024 14:43:35 +0200 Subject: [PATCH 02/52] DynamicType to IDL serializer Signed-off-by: Juan Lopez Fernandez --- include/fastdds/dds/xtypes/utils.hpp | 6 + src/cpp/fastdds/xtypes/utils.cpp | 466 ++++++++++++++++++++++++++- 2 files changed, 470 insertions(+), 2 deletions(-) diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index 4ee461daf84..b8ad6c27368 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -20,9 +20,11 @@ #define FASTDDS_DDS_XTYPES__UTILS_HPP #include +#include #include #include +#include #include namespace eprosima { @@ -47,6 +49,10 @@ FASTDDS_EXPORTED_API ReturnCode_t json_serialize( DynamicDataJsonFormat format, std::ostream& output) noexcept; +// TODO +FASTDDS_EXPORTED_API std::string generate_idl_schema( + const traits::ref_type& dynamic_type); + } // dds } // fastdds } // eprosima diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 31382ffe19a..ff0945d9234 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -12,18 +12,34 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include +#include +#include #include +#include +#include +#include #include -#include - #include +#include #include +#include +#include +#include +#include +#include #include "dynamic_types/DynamicDataImpl.hpp" +#include "dynamic_types/DynamicTypeImpl.hpp" +#include "dynamic_types/DynamicTypeMemberImpl.hpp" +#include "dynamic_types/MemberDescriptorImpl.hpp" +#include "dynamic_types/TypeDescriptorImpl.hpp" +#include "dynamic_types/DynamicDataImpl.hpp" #include "serializers/json/dynamic_data_json.hpp" +#include "utils/collections/Tree.hpp" namespace eprosima { namespace fastdds { @@ -50,4 +66,450 @@ ReturnCode_t json_serialize( } // namespace dds } // namespace fastdds + +/////////////////////////////////////// +// Dynamic Type to IDL serialization // +/////////////////////////////////////// + +//// Forward declarations and constants + +constexpr const char* TYPE_OPENING = + "\n{\n"; + +constexpr const char* TYPE_CLOSURE = + "};\n"; + +constexpr const char* TAB_SEPARATOR = + " "; + +struct TreeNodeType +{ + TreeNodeType( + std::string member_name, + std::string type_kind_name, + DynamicType::_ref_type dynamic_type) + : member_name(member_name) + , type_kind_name(type_kind_name) + , dynamic_type(dynamic_type) + { + } + + std::string member_name; + std::string type_kind_name; + DynamicType::_ref_type dynamic_type; +}; + +std::string type_kind_to_str( + const DynamicType::_ref_type& type); + +//// Implementation + +DynamicType::_ref_type container_internal_type( + const DynamicType::_ref_type& dyn_type) +{ + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = dyn_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Type Descriptor"); + } + return type_descriptor->element_type(); +} + +std::vector container_size( + const DynamicType::_ref_type& dyn_type) +{ + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = dyn_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Type Descriptor"); + } + return type_descriptor->bound(); +} + +std::vector> get_members_sorted( + const DynamicType::_ref_type& dyn_type) +{ + std::vector> result; + + std::map members; + dyn_type->get_all_members(members); + + for (const auto& member : members) + { + ObjectName dyn_name = member.second->get_name(); + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + const auto ret = member.second->get_descriptor(member_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Member Descriptor"); + } + result.emplace_back( + std::make_pair( + dyn_name.to_string(), + std::move(member_descriptor->type()))); + } + return result; +} + +std::string array_kind_to_str( + const DynamicType::_ref_type& dyn_type) +{ + auto internal_type = container_internal_type(dyn_type); + auto this_array_size = container_size(dyn_type); + + std::stringstream ss; + ss << type_kind_to_str(internal_type); + + for (const auto& bound : this_array_size) + { + ss << "[" << bound << "]"; + } + + return ss.str(); +} + +std::string sequence_kind_to_str( + const DynamicType::_ref_type& dyn_type) +{ + auto internal_type = container_internal_type(dyn_type); + auto this_sequence_size = container_size(dyn_type); + + std::stringstream ss; + ss << "sequence<" << type_kind_to_str(internal_type); + + for (const auto& bound : this_sequence_size) + { + ss << ", " << bound; + } + ss << ">"; + + return ss.str(); +} + +std::string map_kind_to_str( + const DynamicType::_ref_type& dyn_type) +{ + std::stringstream ss; + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = dyn_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Type Descriptor"); + } + auto key_type = type_descriptor->key_element_type(); + auto value_type = type_descriptor->element_type(); + ss << "map<" << type_kind_to_str(key_type) << ", " << type_kind_to_str(value_type) << ">"; + + return ss.str(); +} + +std::string type_kind_to_str( + const DynamicType::_ref_type& dyn_type) +{ + switch (dyn_type->get_kind()) + { + case TK_BOOLEAN: + return "boolean"; + + case TK_BYTE: + return "octet"; + + case TK_INT16: + return "short"; + + case TK_INT32: + return "long"; + + case TK_INT64: + return "long long"; + + case TK_UINT16: + return "unsigned short"; + + case TK_UINT32: + return "unsigned long"; + + case TK_UINT64: + return "unsigned long long"; + + case TK_FLOAT32: + return "float"; + + case TK_FLOAT64: + return "double"; + + case TK_FLOAT128: + return "long double"; + + case TK_CHAR8: + return "char"; + + case TK_CHAR16: + return "wchar"; + + case TK_STRING8: + return "string"; + + case TK_STRING16: + return "wstring"; + + case TK_ARRAY: + return array_kind_to_str(dyn_type); + + case TK_SEQUENCE: + return sequence_kind_to_str(dyn_type); + + case TK_MAP: + return map_kind_to_str(dyn_type); + + case TK_STRUCTURE: + case TK_ENUM: + case TK_UNION: + return (dyn_type->get_name()).to_string(); + + case TK_BITSET: + case TK_BITMASK: + case TK_NONE: + //throw utils::UnsupportedException( + // STR_ENTRY << "Type " << dyn_type->get_name() << " is not supported."); + return ""; + + default: + //throw utils::InconsistencyException( + // STR_ENTRY << "Type " << dyn_type->get_name() << " has not correct kind."); + return ""; + + } +} + +utilities::collections::TreeNode generate_dyn_type_tree( + const DynamicType::_ref_type& type, + const std::string& member_name = "PARENT") +{ + // Get kind + TypeKind kind = type->get_kind(); + + switch (kind) + { + case TK_STRUCTURE: + { + // If is struct, the call is recursive. + // Create new tree node + utilities::collections::TreeNode parent(member_name, (type->get_name()).to_string(), type); + + // Get all members of this struct + std::vector> members_by_name = get_members_sorted(type); + + for (const auto& member : members_by_name) + { + // Add each member with its name as a new node in a branch (recursion) + parent.add_branch( + generate_dyn_type_tree(member.second, member.first)); + } + return parent; + } + + case TK_ARRAY: + case TK_SEQUENCE: + { + // If container (array or struct) has exactly one branch + // Calculate child branch + auto internal_type = container_internal_type(type); + + // Create this node + utilities::collections::TreeNode container(member_name, type_kind_to_str(type), type); + // Add branch + container.add_branch(generate_dyn_type_tree(internal_type, "CONTAINER_MEMBER")); + + return container; + } + + default: + return utilities::collections::TreeNode(member_name, type_kind_to_str(type), type); + } +} + +std::ostream& node_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) +{ + os << TAB_SEPARATOR; + + if (node.info.dynamic_type->get_kind() == TK_ARRAY) + { + auto dim_pos = node.info.type_kind_name.find("["); + auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); + auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); + + os << kind_name_str << " " << node.info.member_name << dim_str; + } + else + { + os << node.info.type_kind_name << " " << node.info.member_name; + } + + return os; +} + +std::ostream& struct_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) +{ + // Add types name + os << "struct " << node.info.type_kind_name << TYPE_OPENING; + + // Add struct attributes + for (auto const& child : node.branches()) + { + node_to_str(os, child.info); + os << ";\n"; + } + + // Close definition + os << TYPE_CLOSURE; + + return os; +} + +std::ostream& enum_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) +{ + os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; + + std::map members; + node.info.dynamic_type->get_all_members(members); + bool first_iter = true; + for (const auto& member : members) + { + if (!first_iter) + { + os << ",\n" << TAB_SEPARATOR; + } + first_iter = false; + + os << member.second->get_name(); + } + + // Close definition + os << "\n" << TYPE_CLOSURE; + + return os; +} + +std::ostream& union_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) +{ + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = node.info.dynamic_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Type Descriptor"); + } + os << "union " << node.info.type_kind_name << " switch (" << type_kind_to_str( + type_descriptor->discriminator_type()) << ")" << TYPE_OPENING; + + std::map members; + node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available + for (const auto& member : members) + { + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + const auto ret = member.second->get_descriptor(member_descriptor); + if (ret != RETCODE_OK) + { + //throw utils::InconsistencyException("No Member Descriptor"); + } + auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration + bool first_iter = true; + for (const auto& label : labels) + { + if (first_iter) + { + os << TAB_SEPARATOR; + } + else + { + os << " "; + } + first_iter = false; + + os << "case " << std::to_string(label) << ":"; + } + + os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << type_kind_to_str(member_descriptor->type()) << + " " << member.second->get_name() << ";\n"; + + + } + + // Close definition + os << TYPE_CLOSURE; + + return os; +} + +std::string generate_dyn_type_schema_from_tree( + const utilities::collections::TreeNode& parent_node) +{ + std::set types_written; + + std::stringstream ss; + + // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). + // If it is, check if it is not yet written + // If it is not, write it down + for (const auto& node : parent_node.all_nodes()) + { + auto kind = node.info.dynamic_type->get_kind(); + if (types_written.find(node.info.type_kind_name) == types_written.end()) + { + switch (kind) + { + case TK_STRUCTURE: + struct_to_str(ss, node); + break; + + case TK_ENUM: + enum_to_str(ss, node); + break; + + case TK_UNION: + union_to_str(ss, node); + break; + + default: + continue; + } + ss << "\n"; // Introduce blank line between type definitions + types_written.insert(node.info.type_kind_name); + } + } + + // Write struct parent node at last, after all its dependencies + // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent + struct_to_str(ss, parent_node); + + return ss.str(); +} + +std::string generate_idl_schema( + const traits::ref_type& dynamic_type) +{ + // Generate type tree + utilities::collections::TreeNode parent_type = generate_dyn_type_tree(dynamic_type); + + // From tree, generate string + return generate_dyn_type_schema_from_tree(parent_type); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//// Dynamic Type to IDL serialization //// END +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +} // namespace dds +} // namespace fastdds } // namespace eprosima From 4e0d2290e724196a778ddc6710c59e9254a10d59 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 12:27:32 +0200 Subject: [PATCH 03/52] Make methods return RETCODES and noexcept Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 5 +- src/cpp/fastdds/xtypes/utils.cpp | 543 +++++++++++++++++++-------- 2 files changed, 385 insertions(+), 163 deletions(-) diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index b8ad6c27368..2b78afe2513 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -50,8 +50,9 @@ FASTDDS_EXPORTED_API ReturnCode_t json_serialize( std::ostream& output) noexcept; // TODO -FASTDDS_EXPORTED_API std::string generate_idl_schema( - const traits::ref_type& dynamic_type); +FASTDDS_EXPORTED_API ReturnCode_t generate_idl_schema( + const traits::ref_type& dynamic_type, + std::string& idl_schema) noexcept; } // dds } // fastdds diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index ff0945d9234..7ce9c76a1b3 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -22,6 +22,7 @@ #include +#include #include #include #include @@ -99,242 +100,414 @@ struct TreeNodeType DynamicType::_ref_type dynamic_type; }; -std::string type_kind_to_str( - const DynamicType::_ref_type& type); +ReturnCode_t type_kind_to_str( + const DynamicType::_ref_type& type, + std::string& type_str) noexcept; //// Implementation -DynamicType::_ref_type container_internal_type( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t container_internal_type( + const DynamicType::_ref_type& dyn_type, + DynamicType::_ref_type& internal_type) noexcept { TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; const auto ret = dyn_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Type Descriptor"); + return ret; } - return type_descriptor->element_type(); + + internal_type = type_descriptor->element_type(); + + return RETCODE_OK; } -std::vector container_size( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t container_size( + const DynamicType::_ref_type& dyn_type, + BoundSeq& bounds) noexcept { TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; const auto ret = dyn_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Type Descriptor"); + return ret; } - return type_descriptor->bound(); + + bounds = type_descriptor->bound(); + + return RETCODE_OK; } -std::vector> get_members_sorted( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t get_members_sorted( + const DynamicType::_ref_type& dyn_type, + std::vector>& result) noexcept { - std::vector> result; - std::map members; dyn_type->get_all_members(members); for (const auto& member : members) { - ObjectName dyn_name = member.second->get_name(); MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; const auto ret = member.second->get_descriptor(member_descriptor); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Member Descriptor"); + return ret; } + + const auto dyn_name = member.second->get_name(); result.emplace_back( std::make_pair( dyn_name.to_string(), std::move(member_descriptor->type()))); } - return result; + + return RETCODE_OK; } -std::string array_kind_to_str( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t array_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& array_str) noexcept { - auto internal_type = container_internal_type(dyn_type); - auto this_array_size = container_size(dyn_type); + ReturnCode_t ret = RETCODE_OK; - std::stringstream ss; - ss << type_kind_to_str(internal_type); + DynamicType::_ref_type internal_type; + ret = container_internal_type(dyn_type, internal_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + ret = type_kind_to_str(internal_type, array_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + BoundSeq bounds; + ret = container_size(dyn_type, bounds); + + if (ret != RETCODE_OK) + { + return ret; + } - for (const auto& bound : this_array_size) + for (const auto& bound : bounds) { - ss << "[" << bound << "]"; + array_str += "["; + array_str += bound; + array_str += "]"; } - return ss.str(); + return ret; } -std::string sequence_kind_to_str( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t sequence_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& sequence_str) noexcept { - auto internal_type = container_internal_type(dyn_type); - auto this_sequence_size = container_size(dyn_type); + ReturnCode_t ret = RETCODE_OK; - std::stringstream ss; - ss << "sequence<" << type_kind_to_str(internal_type); + DynamicType::_ref_type internal_type; + ret = container_internal_type(dyn_type, internal_type); - for (const auto& bound : this_sequence_size) + if (ret != RETCODE_OK) { - ss << ", " << bound; + return ret; } - ss << ">"; - return ss.str(); + ret = type_kind_to_str(internal_type, sequence_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + sequence_str = "sequence<" + sequence_str; + + BoundSeq bounds; + ret = container_size(dyn_type, bounds); + + if (ret != RETCODE_OK) + { + return ret; + } + + for (const auto& bound : bounds) + { + sequence_str += ", " + bound; + } + + sequence_str += ">"; + + return ret; } -std::string map_kind_to_str( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t map_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& map_str) noexcept { - std::stringstream ss; + ReturnCode_t ret = RETCODE_OK; + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = dyn_type->get_descriptor(type_descriptor); + ret = dyn_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string key_str; + const auto key_type = type_descriptor->key_element_type(); + ret = type_kind_to_str(key_type, key_str); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Type Descriptor"); + return ret; } - auto key_type = type_descriptor->key_element_type(); - auto value_type = type_descriptor->element_type(); - ss << "map<" << type_kind_to_str(key_type) << ", " << type_kind_to_str(value_type) << ">"; - return ss.str(); + std::string value_str; + const auto value_type = type_descriptor->element_type(); + ret = type_kind_to_str(value_type, value_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::stringstream ss; + + ss << "map<" << key_str << ", " << value_str << ">"; + + map_str = ss.str(); + + return ret; } -std::string type_kind_to_str( - const DynamicType::_ref_type& dyn_type) +ReturnCode_t type_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& type_str) noexcept { + ReturnCode_t ret = RETCODE_OK; + switch (dyn_type->get_kind()) { case TK_BOOLEAN: - return "boolean"; - + { + type_str = "boolean"; + break; + } case TK_BYTE: - return "octet"; - + { + type_str = "octet"; + break; + } case TK_INT16: - return "short"; - + { + type_str = "short"; + break; + } case TK_INT32: - return "long"; - + { + type_str = "long"; + break; + } case TK_INT64: - return "long long"; - + { + type_str = "long long"; + break; + } case TK_UINT16: - return "unsigned short"; - + { + type_str = "unsigned short"; + break; + } case TK_UINT32: - return "unsigned long"; - + { + type_str = "unsigned long"; + break; + } case TK_UINT64: - return "unsigned long long"; - + { + type_str = "unsigned long long"; + break; + } case TK_FLOAT32: - return "float"; - + { + type_str = "float"; + break; + } case TK_FLOAT64: - return "double"; - + { + type_str = "double"; + break; + } case TK_FLOAT128: - return "long double"; - + { + type_str = "long double"; + break; + } case TK_CHAR8: - return "char"; - + { + type_str = "char"; + break; + } case TK_CHAR16: - return "wchar"; - + { + type_str = "wchar"; + break; + } case TK_STRING8: - return "string"; - + { + type_str = "string"; + break; + } case TK_STRING16: - return "wstring"; - + { + type_str = "wstring"; + break; + } case TK_ARRAY: - return array_kind_to_str(dyn_type); - + { + ret = array_kind_to_str(dyn_type, type_str); + break; + } case TK_SEQUENCE: - return sequence_kind_to_str(dyn_type); - + { + ret = sequence_kind_to_str(dyn_type, type_str); + break; + } case TK_MAP: - return map_kind_to_str(dyn_type); - + { + ret = map_kind_to_str(dyn_type, type_str); + break; + } case TK_STRUCTURE: case TK_ENUM: case TK_UNION: - return (dyn_type->get_name()).to_string(); - + { + type_str = dyn_type->get_name().to_string(); + break; + } case TK_BITSET: case TK_BITMASK: case TK_NONE: - //throw utils::UnsupportedException( - // STR_ENTRY << "Type " << dyn_type->get_name() << " is not supported."); - return ""; - + case TK_ALIAS: + { + ret = RETCODE_UNSUPPORTED; + break; + } default: - //throw utils::InconsistencyException( - // STR_ENTRY << "Type " << dyn_type->get_name() << " has not correct kind."); - return ""; - + { + ret = RETCODE_BAD_PARAMETER; + break; + } } + + return ret; } -utilities::collections::TreeNode generate_dyn_type_tree( +ReturnCode_t generate_dyn_type_tree( const DynamicType::_ref_type& type, - const std::string& member_name = "PARENT") + const std::string& member_name, + utilities::collections::TreeNode& node) noexcept { - // Get kind - TypeKind kind = type->get_kind(); + ReturnCode_t ret = RETCODE_OK; - switch (kind) + switch (type->get_kind()) { case TK_STRUCTURE: { // If is struct, the call is recursive. // Create new tree node - utilities::collections::TreeNode parent(member_name, (type->get_name()).to_string(), type); + utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); // Get all members of this struct - std::vector> members_by_name = get_members_sorted(type); + std::vector> members_by_name; + ret = get_members_sorted(type, members_by_name); + + if (ret != RETCODE_OK) + { + return ret; + } for (const auto& member : members_by_name) { + ret = generate_dyn_type_tree(member.second, member.first, node); + + if (ret != RETCODE_OK) + { + return ret; + } + // Add each member with its name as a new node in a branch (recursion) - parent.add_branch( - generate_dyn_type_tree(member.second, member.first)); + parent.add_branch(node); } - return parent; - } + node = parent; + break; + } case TK_ARRAY: case TK_SEQUENCE: { // If container (array or struct) has exactly one branch // Calculate child branch - auto internal_type = container_internal_type(type); + DynamicType::_ref_type internal_type; + ret = container_internal_type(type, internal_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string internal_str; + ret = type_kind_to_str(internal_type, internal_str); + + if (ret != RETCODE_OK) + { + return ret; + } // Create this node - utilities::collections::TreeNode container(member_name, type_kind_to_str(type), type); + utilities::collections::TreeNode container(member_name, internal_str, type); // Add branch - container.add_branch(generate_dyn_type_tree(internal_type, "CONTAINER_MEMBER")); + ret = generate_dyn_type_tree(internal_type, "CONTAINER_MEMBER", node); - return container; - } + if (ret != RETCODE_OK) + { + return ret; + } + container.add_branch(node); + + node = container; + break; + } default: - return utilities::collections::TreeNode(member_name, type_kind_to_str(type), type); + { + std::string type_str; + ret = type_kind_to_str(type, type_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + node = utilities::collections::TreeNode(member_name, type_str, type); + break; + } } + + return ret; } -std::ostream& node_to_str( +ReturnCode_t node_to_str( std::ostream& os, - const utilities::collections::TreeNode& node) + const utilities::collections::TreeNode& node) noexcept { os << TAB_SEPARATOR; @@ -351,12 +524,12 @@ std::ostream& node_to_str( os << node.info.type_kind_name << " " << node.info.member_name; } - return os; + return RETCODE_OK; } -std::ostream& struct_to_str( +ReturnCode_t struct_to_str( std::ostream& os, - const utilities::collections::TreeNode& node) + const utilities::collections::TreeNode& node) noexcept { // Add types name os << "struct " << node.info.type_kind_name << TYPE_OPENING; @@ -371,16 +544,16 @@ std::ostream& struct_to_str( // Close definition os << TYPE_CLOSURE; - return os; + return RETCODE_OK; } -std::ostream& enum_to_str( +ReturnCode_t enum_to_str( std::ostream& os, - const utilities::collections::TreeNode& node) + const utilities::collections::TreeNode& node) noexcept { os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; - std::map members; + std::map members; node.info.dynamic_type->get_all_members(members); bool first_iter = true; for (const auto& member : members) @@ -397,34 +570,49 @@ std::ostream& enum_to_str( // Close definition os << "\n" << TYPE_CLOSURE; - return os; + return RETCODE_OK; } -std::ostream& union_to_str( +ReturnCode_t union_to_str( std::ostream& os, - const utilities::collections::TreeNode& node) + const utilities::collections::TreeNode& node) noexcept { + ReturnCode_t ret = RETCODE_OK; + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = node.info.dynamic_type->get_descriptor(type_descriptor); + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Type Descriptor"); + return ret; } - os << "union " << node.info.type_kind_name << " switch (" << type_kind_to_str( - type_descriptor->discriminator_type()) << ")" << TYPE_OPENING; + + std::string discriminant_type_str; + ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + os << "union " << node.info.type_kind_name << " switch (" << discriminant_type_str << ")" << TYPE_OPENING; std::map members; node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available + for (const auto& member : members) { MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - const auto ret = member.second->get_descriptor(member_descriptor); + ret = member.second->get_descriptor(member_descriptor); + if (ret != RETCODE_OK) { - //throw utils::InconsistencyException("No Member Descriptor"); + return ret; } - auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration + + const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration bool first_iter = true; + for (const auto& label : labels) { if (first_iter) @@ -440,20 +628,26 @@ std::ostream& union_to_str( os << "case " << std::to_string(label) << ":"; } - os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << type_kind_to_str(member_descriptor->type()) << - " " << member.second->get_name() << ";\n"; + std::string member_str; + ret = type_kind_to_str(member_descriptor->type(), member_str); + if (ret != RETCODE_OK) + { + return ret; + } + os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << member_str << " " << member.second->get_name() << ";\n"; } // Close definition os << TYPE_CLOSURE; - return os; + return ret; } -std::string generate_dyn_type_schema_from_tree( - const utilities::collections::TreeNode& parent_node) +ReturnCode_t generate_dyn_type_schema_from_tree( + const utilities::collections::TreeNode& parent_node, + std::string& dyn_type_schema) noexcept { std::set types_written; @@ -464,52 +658,79 @@ std::string generate_dyn_type_schema_from_tree( // If it is not, write it down for (const auto& node : parent_node.all_nodes()) { - auto kind = node.info.dynamic_type->get_kind(); - if (types_written.find(node.info.type_kind_name) == types_written.end()) + if (types_written.find(node.info.type_kind_name) != types_written.end()) { - switch (kind) - { - case TK_STRUCTURE: - struct_to_str(ss, node); - break; - - case TK_ENUM: - enum_to_str(ss, node); - break; + continue; + } - case TK_UNION: - union_to_str(ss, node); - break; + ReturnCode_t ret; + const auto kind = node.info.dynamic_type->get_kind(); - default: - continue; + switch (kind) + { + case TK_STRUCTURE: + { + ret = struct_to_str(ss, node); + break; + } + case TK_ENUM: + { + ret = enum_to_str(ss, node); + break; } - ss << "\n"; // Introduce blank line between type definitions - types_written.insert(node.info.type_kind_name); + case TK_UNION: + { + ret = union_to_str(ss, node); + break; + } + default: + continue; + } + + if (ret != RETCODE_OK) + { + return ret; } + + ss << "\n"; // Introduce blank line between type definitions + types_written.insert(node.info.type_kind_name); } // Write struct parent node at last, after all its dependencies // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent - struct_to_str(ss, parent_node); + const auto ret = struct_to_str(ss, parent_node); + + if (ret != RETCODE_OK) + { + return ret; + } + + dyn_type_schema = ss.str(); - return ss.str(); + return RETCODE_OK; } -std::string generate_idl_schema( - const traits::ref_type& dynamic_type) +ReturnCode_t generate_idl_schema( + const traits::ref_type& dynamic_type, + std::string& idl_schema) noexcept { // Generate type tree - utilities::collections::TreeNode parent_type = generate_dyn_type_tree(dynamic_type); + utilities::collections::TreeNode parent_type("PARENT", "", dynamic_type); + const auto ret = generate_dyn_type_tree(dynamic_type, "PARENT", parent_type); + + if (ret != RETCODE_OK) + { + return ret; + } // From tree, generate string - return generate_dyn_type_schema_from_tree(parent_type); + return generate_dyn_type_schema_from_tree(parent_type, idl_schema); } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //// Dynamic Type to IDL serialization //// END //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -} // namespace dds -} // namespace fastdds +} // namespace dds +} // namespace fastdds } // namespace eprosima From 7261e85bb5c20ff0cba6d902afe36fcd4ac8e8a9 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 12:31:38 +0200 Subject: [PATCH 04/52] Move TreeNodeType methods to a different file Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 2 +- src/cpp/fastdds/xtypes/dyn_type_tree.hpp | 165 ++++++ src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 650 +++++++++++++++++++++++ src/cpp/fastdds/xtypes/utils.cpp | 18 +- 4 files changed, 824 insertions(+), 11 deletions(-) create mode 100644 src/cpp/fastdds/xtypes/dyn_type_tree.hpp create mode 100644 src/cpp/fastdds/xtypes/dyn_type_tree.ipp diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index 2b78afe2513..44f4146a41a 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -50,7 +50,7 @@ FASTDDS_EXPORTED_API ReturnCode_t json_serialize( std::ostream& output) noexcept; // TODO -FASTDDS_EXPORTED_API ReturnCode_t generate_idl_schema( +FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( const traits::ref_type& dynamic_type, std::string& idl_schema) noexcept; diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp new file mode 100644 index 00000000000..cbd5776111b --- /dev/null +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp @@ -0,0 +1,165 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file dyn_type_tree.hpp + */ + +#ifndef _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ +#define _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ + +#include +#include +#include + +#include +#include +#include + +#include "utils/collections/Tree.hpp" + +namespace eprosima { +namespace fastdds { +namespace dds { + +struct TreeNodeType +{ + TreeNodeType() + { + } + + TreeNodeType( + const std::string& member_name, + const std::string& type_kind_name, + const DynamicType::_ref_type& dynamic_type) + : member_name(member_name) + , type_kind_name(type_kind_name) + , dynamic_type(dynamic_type) + { + } + + std::string member_name; + std::string type_kind_name; + DynamicType::_ref_type dynamic_type; +}; + + +////////////////////////// +// DYNAMIC TYPE TO TREE // +////////////////////////// + +/** + * TODO + */ +ReturnCode_t dyn_type_to_tree( + const DynamicType::_ref_type& type, + const std::string& member_name, + utilities::collections::TreeNode& node) noexcept; + +/** + * TODO + */ +ReturnCode_t type_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& type_str) noexcept; + +/** + * TODO + */ +ReturnCode_t array_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& array_str) noexcept; + +/** + * TODO + */ +ReturnCode_t sequence_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& sequence_str) noexcept; + +/** + * TODO + */ +ReturnCode_t map_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& map_str) noexcept; + +/** + * TODO + */ +ReturnCode_t get_members_sorted( + const DynamicType::_ref_type& dyn_type, + std::vector>& result) noexcept; + +/** + * TODO + */ +ReturnCode_t container_internal_type( + const DynamicType::_ref_type& dyn_type, + DynamicType::_ref_type& internal_type) noexcept; + +/** + * TODO + */ +ReturnCode_t container_size( + const DynamicType::_ref_type& dyn_type, + BoundSeq& bounds) noexcept; + + +////////////////////////////// +// DYNAMIC TYPE TREE TO IDL // +////////////////////////////// + +/** + * TODO + */ +ReturnCode_t dyn_type_tree_to_idl( + const utilities::collections::TreeNode& parent_node, + std::string& dyn_type_idl) noexcept; + +/** + * TODO + */ +ReturnCode_t struct_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept; + +/** + * TODO + */ +ReturnCode_t enum_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept; + +/** + * TODO + */ +ReturnCode_t union_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept; + +/** + * TODO + */ +ReturnCode_t node_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept; + +} // dds +} // fastdds +} // eprosima + +#include "dyn_type_tree.ipp" + +#endif // _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp new file mode 100644 index 00000000000..0ba2a888a19 --- /dev/null +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -0,0 +1,650 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include +#include + +#include +#include +#include + + +namespace eprosima { +namespace fastdds { +namespace dds { + +constexpr auto TYPE_OPENING = "\n{\n"; +constexpr auto TYPE_CLOSURE = "};\n"; +constexpr auto TAB_SEPARATOR = " "; + + +////////////////////////// +// DYNAMIC TYPE TO TREE // +////////////////////////// + +ReturnCode_t dyn_type_to_tree( + const DynamicType::_ref_type& type, + const std::string& member_name, + utilities::collections::TreeNode& node) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + switch (type->get_kind()) + { + case TK_STRUCTURE: + { + // If is struct, the call is recursive. + // Create new tree node + utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); + + // Get all members of this struct + std::vector> members_by_name; + ret = get_members_sorted(type, members_by_name); + + if (ret != RETCODE_OK) + { + return ret; + } + + for (const auto& member : members_by_name) + { + ret = dyn_type_to_tree(member.second, member.first, node); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Add each member with its name as a new node in a branch (recursion) + parent.add_branch(node); + } + + node = parent; + break; + } + case TK_ARRAY: + case TK_SEQUENCE: + { + // If container (array or struct) has exactly one branch + // Calculate child branch + DynamicType::_ref_type internal_type; + ret = container_internal_type(type, internal_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string internal_str; + ret = type_kind_to_str(internal_type, internal_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Create this node + utilities::collections::TreeNode container(member_name, internal_str, type); + // Add branch + ret = dyn_type_to_tree(internal_type, "CONTAINER_MEMBER", node); + + if (ret != RETCODE_OK) + { + return ret; + } + + container.add_branch(node); + + node = container; + break; + } + default: + { + std::string type_str; + ret = type_kind_to_str(type, type_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + node = utilities::collections::TreeNode(member_name, type_str, type); + break; + } + } + + return ret; +} + +ReturnCode_t type_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& type_str) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + switch (dyn_type->get_kind()) + { + case TK_BOOLEAN: + { + type_str = "boolean"; + break; + } + case TK_BYTE: + { + type_str = "octet"; + break; + } + case TK_INT16: + { + type_str = "short"; + break; + } + case TK_INT32: + { + type_str = "long"; + break; + } + case TK_INT64: + { + type_str = "long long"; + break; + } + case TK_UINT16: + { + type_str = "unsigned short"; + break; + } + case TK_UINT32: + { + type_str = "unsigned long"; + break; + } + case TK_UINT64: + { + type_str = "unsigned long long"; + break; + } + case TK_FLOAT32: + { + type_str = "float"; + break; + } + case TK_FLOAT64: + { + type_str = "double"; + break; + } + case TK_FLOAT128: + { + type_str = "long double"; + break; + } + case TK_CHAR8: + { + type_str = "char"; + break; + } + case TK_CHAR16: + { + type_str = "wchar"; + break; + } + case TK_STRING8: + { + type_str = "string"; + break; + } + case TK_STRING16: + { + type_str = "wstring"; + break; + } + case TK_ARRAY: + { + ret = array_kind_to_str(dyn_type, type_str); + break; + } + case TK_SEQUENCE: + { + ret = sequence_kind_to_str(dyn_type, type_str); + break; + } + case TK_MAP: + { + ret = map_kind_to_str(dyn_type, type_str); + break; + } + case TK_STRUCTURE: + case TK_ENUM: + case TK_UNION: + { + type_str = dyn_type->get_name().to_string(); + break; + } + case TK_BITSET: + case TK_BITMASK: + case TK_NONE: + case TK_ALIAS: + { + ret = RETCODE_UNSUPPORTED; + break; + } + default: + { + ret = RETCODE_BAD_PARAMETER; + break; + } + } + + return ret; +} + +ReturnCode_t array_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& array_str) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + DynamicType::_ref_type internal_type; + ret = container_internal_type(dyn_type, internal_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + ret = type_kind_to_str(internal_type, array_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + BoundSeq bounds; + ret = container_size(dyn_type, bounds); + + if (ret != RETCODE_OK) + { + return ret; + } + + for (const auto& bound : bounds) + { + array_str += "["; + array_str += bound; + array_str += "]"; + } + + return ret; +} + +ReturnCode_t sequence_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& sequence_str) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + DynamicType::_ref_type internal_type; + ret = container_internal_type(dyn_type, internal_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + ret = type_kind_to_str(internal_type, sequence_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + sequence_str = "sequence<" + sequence_str; + + BoundSeq bounds; + ret = container_size(dyn_type, bounds); + + if (ret != RETCODE_OK) + { + return ret; + } + + for (const auto& bound : bounds) + { + sequence_str += ", " + bound; + } + + sequence_str += ">"; + + return ret; +} + +ReturnCode_t map_kind_to_str( + const DynamicType::_ref_type& dyn_type, + std::string& map_str) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = dyn_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string key_str; + const auto key_type = type_descriptor->key_element_type(); + ret = type_kind_to_str(key_type, key_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string value_str; + const auto value_type = type_descriptor->element_type(); + ret = type_kind_to_str(value_type, value_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::stringstream ss; + + ss << "map<" << key_str << ", " << value_str << ">"; + + map_str = ss.str(); + + return ret; +} + +ReturnCode_t get_members_sorted( + const DynamicType::_ref_type& dyn_type, + std::vector>& result) noexcept +{ + std::map members; + dyn_type->get_all_members(members); + + for (const auto& member : members) + { + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + const auto ret = member.second->get_descriptor(member_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + const auto dyn_name = member.second->get_name(); + result.emplace_back( + std::make_pair( + dyn_name.to_string(), + std::move(member_descriptor->type()))); + } + + return RETCODE_OK; +} + +ReturnCode_t container_internal_type( + const DynamicType::_ref_type& dyn_type, + DynamicType::_ref_type& internal_type) noexcept +{ + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = dyn_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + internal_type = type_descriptor->element_type(); + + return RETCODE_OK; +} + +ReturnCode_t container_size( + const DynamicType::_ref_type& dyn_type, + BoundSeq& bounds) noexcept +{ + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + const auto ret = dyn_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + bounds = type_descriptor->bound(); + + return RETCODE_OK; +} + + +////////////////////////////// +// DYNAMIC TYPE TREE TO IDL // +////////////////////////////// + +ReturnCode_t dyn_type_tree_to_idl( + const utilities::collections::TreeNode& parent_node, + std::string& dyn_type_idl) noexcept +{ + std::set types_written; + + std::stringstream ss; + + // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). + // If it is, check if it is not yet written + // If it is not, write it down + for (const auto& node : parent_node.all_nodes()) + { + if (types_written.find(node.info.type_kind_name) != types_written.end()) + { + continue; + } + + ReturnCode_t ret; + const auto kind = node.info.dynamic_type->get_kind(); + + switch (kind) + { + case TK_STRUCTURE: + { + ret = struct_to_str(ss, node); + break; + } + case TK_ENUM: + { + ret = enum_to_str(ss, node); + break; + } + case TK_UNION: + { + ret = union_to_str(ss, node); + break; + } + default: + continue; + } + + if (ret != RETCODE_OK) + { + return ret; + } + + ss << "\n"; // Introduce blank line between type definitions + types_written.insert(node.info.type_kind_name); + } + + // Write struct parent node at last, after all its dependencies + // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent + const auto ret = struct_to_str(ss, parent_node); + + if (ret != RETCODE_OK) + { + return ret; + } + + dyn_type_idl = ss.str(); + + return RETCODE_OK; +} + +ReturnCode_t struct_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept +{ + // Add types name + os << "struct " << node.info.type_kind_name << TYPE_OPENING; + + // Add struct attributes + for (auto const& child : node.branches()) + { + node_to_str(os, child.info); + os << ";\n"; + } + + // Close definition + os << TYPE_CLOSURE; + + return RETCODE_OK; +} + +ReturnCode_t enum_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept +{ + os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; + + std::map members; + node.info.dynamic_type->get_all_members(members); + bool first_iter = true; + for (const auto& member : members) + { + if (!first_iter) + { + os << ",\n" << TAB_SEPARATOR; + } + first_iter = false; + + os << member.second->get_name(); + } + + // Close definition + os << "\n" << TYPE_CLOSURE; + + return RETCODE_OK; +} + +ReturnCode_t union_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + std::string discriminant_type_str; + ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + os << "union " << node.info.type_kind_name << " switch (" << discriminant_type_str << ")" << TYPE_OPENING; + + std::map members; + node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available + + for (const auto& member : members) + { + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member.second->get_descriptor(member_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration + bool first_iter = true; + + for (const auto& label : labels) + { + if (first_iter) + { + os << TAB_SEPARATOR; + } + else + { + os << " "; + } + first_iter = false; + + os << "case " << std::to_string(label) << ":"; + } + + std::string member_str; + ret = type_kind_to_str(member_descriptor->type(), member_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << member_str << " " << member.second->get_name() << ";\n"; + } + + // Close definition + os << TYPE_CLOSURE; + + return ret; +} + +ReturnCode_t node_to_str( + std::ostream& os, + const utilities::collections::TreeNode& node) noexcept +{ + os << TAB_SEPARATOR; + + if (node.info.dynamic_type->get_kind() == TK_ARRAY) + { + auto dim_pos = node.info.type_kind_name.find("["); + auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); + auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); + + os << kind_name_str << " " << node.info.member_name << dim_str; + } + else + { + os << node.info.type_kind_name << " " << node.info.member_name; + } + + return RETCODE_OK; +} + +} // namespace dds +} // namespace fastdds +} // namespace eprosima diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 7ce9c76a1b3..edb0e446bd0 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -40,6 +40,8 @@ #include "dynamic_types/DynamicDataImpl.hpp" #include "serializers/json/dynamic_data_json.hpp" +#include "dyn_type_tree.hpp" + #include "utils/collections/Tree.hpp" namespace eprosima { @@ -710,27 +712,23 @@ ReturnCode_t generate_dyn_type_schema_from_tree( return RETCODE_OK; } -ReturnCode_t generate_idl_schema( +ReturnCode_t idl_serialize( const traits::ref_type& dynamic_type, std::string& idl_schema) noexcept { - // Generate type tree - utilities::collections::TreeNode parent_type("PARENT", "", dynamic_type); - const auto ret = generate_dyn_type_tree(dynamic_type, "PARENT", parent_type); + // Create a tree representation of the dynamic type + utilities::collections::TreeNode parent_type; + const auto ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); if (ret != RETCODE_OK) { return ret; } - // From tree, generate string - return generate_dyn_type_schema_from_tree(parent_type, idl_schema); + // Serialize the tree to IDL + return dyn_type_tree_to_idl(parent_type, idl_schema); } -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -//// Dynamic Type to IDL serialization //// END -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - } // namespace dds } // namespace fastdds } // namespace eprosima From c1d83b6aa4d37ecb366661d4eb5174dfa39731c3 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 12:41:28 +0200 Subject: [PATCH 05/52] Check ReturnCodes from the DynamicTypes API Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 55 +++++++++++++++++------- 1 file changed, 40 insertions(+), 15 deletions(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 0ba2a888a19..5bcb336cb83 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -378,13 +378,20 @@ ReturnCode_t get_members_sorted( const DynamicType::_ref_type& dyn_type, std::vector>& result) noexcept { + ReturnCode_t ret = RETCODE_OK; + std::map members; - dyn_type->get_all_members(members); + ret = dyn_type->get_all_members(members); + + if (ret != RETCODE_OK) + { + return ret; + } for (const auto& member : members) { MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - const auto ret = member.second->get_descriptor(member_descriptor); + ret = member.second->get_descriptor(member_descriptor); if (ret != RETCODE_OK) { @@ -398,15 +405,17 @@ ReturnCode_t get_members_sorted( std::move(member_descriptor->type()))); } - return RETCODE_OK; + return ret; } ReturnCode_t container_internal_type( const DynamicType::_ref_type& dyn_type, DynamicType::_ref_type& internal_type) noexcept { + ReturnCode_t ret = RETCODE_OK; + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = dyn_type->get_descriptor(type_descriptor); + ret = dyn_type->get_descriptor(type_descriptor); if (ret != RETCODE_OK) { @@ -415,15 +424,17 @@ ReturnCode_t container_internal_type( internal_type = type_descriptor->element_type(); - return RETCODE_OK; + return ret; } ReturnCode_t container_size( const DynamicType::_ref_type& dyn_type, BoundSeq& bounds) noexcept { + ReturnCode_t ret = RETCODE_OK; + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = dyn_type->get_descriptor(type_descriptor); + ret = dyn_type->get_descriptor(type_descriptor); if (ret != RETCODE_OK) { @@ -432,7 +443,7 @@ ReturnCode_t container_size( bounds = type_descriptor->bound(); - return RETCODE_OK; + return ret; } @@ -444,8 +455,9 @@ ReturnCode_t dyn_type_tree_to_idl( const utilities::collections::TreeNode& parent_node, std::string& dyn_type_idl) noexcept { - std::set types_written; + ReturnCode_t ret = RETCODE_OK; + std::set types_written; std::stringstream ss; // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). @@ -458,7 +470,6 @@ ReturnCode_t dyn_type_tree_to_idl( continue; } - ReturnCode_t ret; const auto kind = node.info.dynamic_type->get_kind(); switch (kind) @@ -493,7 +504,7 @@ ReturnCode_t dyn_type_tree_to_idl( // Write struct parent node at last, after all its dependencies // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent - const auto ret = struct_to_str(ss, parent_node); + ret = struct_to_str(ss, parent_node); if (ret != RETCODE_OK) { @@ -502,7 +513,7 @@ ReturnCode_t dyn_type_tree_to_idl( dyn_type_idl = ss.str(); - return RETCODE_OK; + return ret; } ReturnCode_t struct_to_str( @@ -529,17 +540,26 @@ ReturnCode_t enum_to_str( std::ostream& os, const utilities::collections::TreeNode& node) noexcept { - os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; + ReturnCode_t ret = RETCODE_OK; std::map members; - node.info.dynamic_type->get_all_members(members); + ret = node.info.dynamic_type->get_all_members(members); + + if (ret != RETCODE_OK) + { + return ret; + } + + os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; bool first_iter = true; + for (const auto& member : members) { if (!first_iter) { os << ",\n" << TAB_SEPARATOR; } + first_iter = false; os << member.second->get_name(); @@ -548,7 +568,7 @@ ReturnCode_t enum_to_str( // Close definition os << "\n" << TYPE_CLOSURE; - return RETCODE_OK; + return ret; } ReturnCode_t union_to_str( @@ -576,7 +596,12 @@ ReturnCode_t union_to_str( os << "union " << node.info.type_kind_name << " switch (" << discriminant_type_str << ")" << TYPE_OPENING; std::map members; - node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available + ret = node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available + + if (ret != RETCODE_OK) + { + return ret; + } for (const auto& member : members) { From d6819c7a39d42acd6da15aec61a5b26292951975 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 14:16:27 +0200 Subject: [PATCH 06/52] Replace ostream with string Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.hpp | 16 ++--- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 75 ++++++++++++++---------- 2 files changed, 51 insertions(+), 40 deletions(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp index cbd5776111b..b7c3d2dd81c 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp @@ -132,29 +132,29 @@ ReturnCode_t dyn_type_tree_to_idl( * TODO */ ReturnCode_t struct_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept; + const utilities::collections::TreeNode& node, + std::string& struct_str) noexcept; /** * TODO */ ReturnCode_t enum_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept; + const utilities::collections::TreeNode& node, + std::string& enum_str) noexcept; /** * TODO */ ReturnCode_t union_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept; + const utilities::collections::TreeNode& node, + std::string& union_str) noexcept; /** * TODO */ ReturnCode_t node_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept; + const utilities::collections::TreeNode& node, + std::string& node_str) noexcept; } // dds } // fastdds diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 5bcb336cb83..87983fd1e81 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -458,7 +458,6 @@ ReturnCode_t dyn_type_tree_to_idl( ReturnCode_t ret = RETCODE_OK; std::set types_written; - std::stringstream ss; // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). // If it is, check if it is not yet written @@ -470,23 +469,24 @@ ReturnCode_t dyn_type_tree_to_idl( continue; } + std::string kind_str; const auto kind = node.info.dynamic_type->get_kind(); switch (kind) { case TK_STRUCTURE: { - ret = struct_to_str(ss, node); + ret = struct_to_str(node, kind_str); break; } case TK_ENUM: { - ret = enum_to_str(ss, node); + ret = enum_to_str(node, kind_str); break; } case TK_UNION: { - ret = union_to_str(ss, node); + ret = union_to_str(node, kind_str); break; } default: @@ -498,47 +498,50 @@ ReturnCode_t dyn_type_tree_to_idl( return ret; } - ss << "\n"; // Introduce blank line between type definitions + dyn_type_idl += kind_str + "\n"; types_written.insert(node.info.type_kind_name); } // Write struct parent node at last, after all its dependencies // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent - ret = struct_to_str(ss, parent_node); + std::string struct_str; + ret = struct_to_str(parent_node, struct_str); if (ret != RETCODE_OK) { return ret; } - dyn_type_idl = ss.str(); + dyn_type_idl += struct_str; return ret; } ReturnCode_t struct_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept + const utilities::collections::TreeNode& node, + std::string& struct_str) noexcept { // Add types name - os << "struct " << node.info.type_kind_name << TYPE_OPENING; + struct_str = "struct " + node.info.type_kind_name + TYPE_OPENING; // Add struct attributes for (auto const& child : node.branches()) { - node_to_str(os, child.info); - os << ";\n"; + std::string child_str; + node_to_str(child.info, child_str); + + struct_str += child_str + ";\n"; } // Close definition - os << TYPE_CLOSURE; + struct_str += TYPE_CLOSURE; return RETCODE_OK; } ReturnCode_t enum_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept + const utilities::collections::TreeNode& node, + std::string& enum_str) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -550,30 +553,32 @@ ReturnCode_t enum_to_str( return ret; } - os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; + enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; bool first_iter = true; for (const auto& member : members) { if (!first_iter) { - os << ",\n" << TAB_SEPARATOR; + enum_str += ",\n"; + enum_str += TAB_SEPARATOR; } first_iter = false; - os << member.second->get_name(); + enum_str += member.second->get_name(); } // Close definition - os << "\n" << TYPE_CLOSURE; + enum_str += "\n"; + enum_str += TYPE_CLOSURE; return ret; } ReturnCode_t union_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept + const utilities::collections::TreeNode& node, + std::string& union_str) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -593,7 +598,7 @@ ReturnCode_t union_to_str( return ret; } - os << "union " << node.info.type_kind_name << " switch (" << discriminant_type_str << ")" << TYPE_OPENING; + union_str = "union " + node.info.type_kind_name + " switch (" + discriminant_type_str + ")" + TYPE_OPENING; std::map members; ret = node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available @@ -620,15 +625,16 @@ ReturnCode_t union_to_str( { if (first_iter) { - os << TAB_SEPARATOR; + union_str += TAB_SEPARATOR; } else { - os << " "; + union_str += " "; } + first_iter = false; - os << "case " << std::to_string(label) << ":"; + union_str += "case " + std::to_string(label) + ":"; } std::string member_str; @@ -639,20 +645,25 @@ ReturnCode_t union_to_str( return ret; } - os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << member_str << " " << member.second->get_name() << ";\n"; + union_str += "\n"; + union_str += TAB_SEPARATOR; + union_str += TAB_SEPARATOR; + union_str += member_str + " "; + union_str += member.second->get_name(); + union_str += ";\n"; } // Close definition - os << TYPE_CLOSURE; + union_str += TYPE_CLOSURE; return ret; } ReturnCode_t node_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept + const utilities::collections::TreeNode& node, + std::string& node_str) noexcept { - os << TAB_SEPARATOR; + node_str = TAB_SEPARATOR; if (node.info.dynamic_type->get_kind() == TK_ARRAY) { @@ -660,11 +671,11 @@ ReturnCode_t node_to_str( auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); - os << kind_name_str << " " << node.info.member_name << dim_str; + node_str += kind_name_str + " " + node.info.member_name + dim_str; } else { - os << node.info.type_kind_name << " " << node.info.member_name; + node_str += node.info.type_kind_name + " " + node.info.member_name; } return RETCODE_OK; From 6278ce693abdcd19262b866250328dedeb499b0a Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 14:37:30 +0200 Subject: [PATCH 07/52] Cover unbounded sequence scenario Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 87983fd1e81..0e7a84fd669 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include #include #include #include @@ -325,7 +326,14 @@ ReturnCode_t sequence_kind_to_str( for (const auto& bound : bounds) { - sequence_str += ", " + bound; + if (bound == static_cast(LENGTH_UNLIMITED)) + { + sequence_str += ", unbounded"; + } + else + { + sequence_str += ", " + bound; + } } sequence_str += ">"; From 96532d671a27225d12ad780244a2da963dd128dd Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 14:39:17 +0200 Subject: [PATCH 08/52] Support TK_INT8 & TK_UINT8 Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 0e7a84fd669..88c5a66ebdc 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -149,6 +149,11 @@ ReturnCode_t type_kind_to_str( type_str = "octet"; break; } + case TK_INT8: + { + type_str = "char"; + break; + } case TK_INT16: { type_str = "short"; @@ -164,6 +169,11 @@ ReturnCode_t type_kind_to_str( type_str = "long long"; break; } + case TK_UINT8: + { + type_str = "unsigned char"; + break; + } case TK_UINT16: { type_str = "unsigned short"; From 7a31baaea791ddf7aa73c01b896303cb7ebca048 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 14:53:35 +0200 Subject: [PATCH 09/52] Include safety checks Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 37 ++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 88c5a66ebdc..ef360f41bfc 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -20,6 +20,7 @@ #include #include +#include #include #include @@ -268,6 +269,12 @@ ReturnCode_t array_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& array_str) noexcept { + if (dyn_type->get_kind() != TK_ARRAY) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an array."); + return RETCODE_BAD_PARAMETER; + } + ReturnCode_t ret = RETCODE_OK; DynamicType::_ref_type internal_type; @@ -307,6 +314,12 @@ ReturnCode_t sequence_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& sequence_str) noexcept { + if (dyn_type->get_kind() != TK_SEQUENCE) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a sequence."); + return RETCODE_BAD_PARAMETER; + } + ReturnCode_t ret = RETCODE_OK; DynamicType::_ref_type internal_type; @@ -355,6 +368,12 @@ ReturnCode_t map_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& map_str) noexcept { + if (dyn_type->get_kind() != TK_MAP) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a map."); + return RETCODE_BAD_PARAMETER; + } + ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; @@ -539,6 +558,12 @@ ReturnCode_t struct_to_str( const utilities::collections::TreeNode& node, std::string& struct_str) noexcept { + if (node.info.dynamic_type->get_kind() != TK_STRUCTURE) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a struct."); + return RETCODE_BAD_PARAMETER; + } + // Add types name struct_str = "struct " + node.info.type_kind_name + TYPE_OPENING; @@ -561,6 +586,12 @@ ReturnCode_t enum_to_str( const utilities::collections::TreeNode& node, std::string& enum_str) noexcept { + if (node.info.dynamic_type->get_kind() != TK_ENUM) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an enum."); + return RETCODE_BAD_PARAMETER; + } + ReturnCode_t ret = RETCODE_OK; std::map members; @@ -598,6 +629,12 @@ ReturnCode_t union_to_str( const utilities::collections::TreeNode& node, std::string& union_str) noexcept { + if (node.info.dynamic_type->get_kind() != TK_UNION) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a union."); + return RETCODE_BAD_PARAMETER; + } + ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; From c8a8e94ae29bdd4a3e45a325f50824cc95145ec7 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 18 Jun 2024 15:33:52 +0200 Subject: [PATCH 10/52] Add DOCSTRING descriptions Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 15 +++-- src/cpp/fastdds/xtypes/dyn_type_tree.hpp | 72 ++++++++++++++++++------ src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 30 +++++----- src/cpp/fastdds/xtypes/utils.cpp | 4 +- 4 files changed, 83 insertions(+), 38 deletions(-) diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index 44f4146a41a..4b9da03badb 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -37,6 +37,16 @@ enum class DynamicDataJsonFormat EPROSIMA, }; +/** + * @brief Serializes a DynamicType into an IDL schema. + * + * @param [in] dynamic_type The DynamicType to serialize. + * @param [out] output The IDL schema. + */ +FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( + const traits::ref_type& dynamic_type, + std::string& output) noexcept; + /*! * Serializes a @ref DynamicData into a JSON object, which is then dumped into an \c std::ostream. * @param[in] data @ref DynamicData reference to be serialized. @@ -49,11 +59,6 @@ FASTDDS_EXPORTED_API ReturnCode_t json_serialize( DynamicDataJsonFormat format, std::ostream& output) noexcept; -// TODO -FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( - const traits::ref_type& dynamic_type, - std::string& idl_schema) noexcept; - } // dds } // fastdds } // eprosima diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp index b7c3d2dd81c..2a212cce494 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.hpp @@ -60,7 +60,11 @@ struct TreeNodeType ////////////////////////// /** - * TODO + * @brief Converts a DynamicType to a tree. + * + * @param type The DynamicType to represent as a tree. + * @param member_name The name of the root node. + * @param node The root node of the tree. */ ReturnCode_t dyn_type_to_tree( const DynamicType::_ref_type& type, @@ -68,49 +72,70 @@ ReturnCode_t dyn_type_to_tree( utilities::collections::TreeNode& node) noexcept; /** - * TODO + * @brief Converts a DynamicType to a string. + * + * @param dyn_type The DynamicType to convert. + * @param type_str The string representation of the DynamicType. */ -ReturnCode_t type_kind_to_str( +ReturnCode_t dyn_type_to_str( const DynamicType::_ref_type& dyn_type, std::string& type_str) noexcept; /** - * TODO + * @brief Converts a DynamicType of \c TK_ARRAY kind to a string. + * + * @param dyn_type The DynamicType kind to convert. + * @param array_str The string representation of the DynamicType kind. */ ReturnCode_t array_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& array_str) noexcept; /** - * TODO + * @brief Converts a DynamicType of \c TK_SEQUENCE kind to a string. + * + * @param dyn_type The DynamicType to convert. + * @param sequence_str The string representation of the DynamicType. */ ReturnCode_t sequence_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& sequence_str) noexcept; /** - * TODO + * @brief Converts a DynamicType of \c TK_MAP kind to a string. + * + * @param dyn_type The DynamicType to convert. + * @param map_str The string representation of the DynamicType. */ ReturnCode_t map_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& map_str) noexcept; /** - * TODO + * @brief Gathers the members of a DynamicType. + * + * @param dyn_type The DynamicType to gather the members from. + * @param result The vector of (name, type) to store the members. */ ReturnCode_t get_members_sorted( const DynamicType::_ref_type& dyn_type, std::vector>& result) noexcept; /** - * TODO + * @brief Gathers the \c element_type of the DynamicType. + * + * @param dyn_type The DynamicType to gather the members from. + * @param internal_type The internal type of the DynamicType's \c type_descriptor. */ ReturnCode_t container_internal_type( const DynamicType::_ref_type& dyn_type, DynamicType::_ref_type& internal_type) noexcept; /** - * TODO + * @brief Gathers the \c bounds of the DynamicType. + * + * @param dyn_type The DynamicType to gather the members from. + * @param bounds The vector to store the bounds in. */ ReturnCode_t container_size( const DynamicType::_ref_type& dyn_type, @@ -122,35 +147,50 @@ ReturnCode_t container_size( ////////////////////////////// /** - * TODO + * @brief Converts a tree to an IDL string. + * + * @param root The root node of the tree. + * @param dyn_type_str The string representation of the tree. */ ReturnCode_t dyn_type_tree_to_idl( - const utilities::collections::TreeNode& parent_node, - std::string& dyn_type_idl) noexcept; + const utilities::collections::TreeNode& root, + std::string& dyn_type_str) noexcept; /** - * TODO + * @brief Converts a tree with a \c TK_STRUCTURE root to an IDL string. + * + * @param node The root node of the tree. + * @param struct_str The string representation of the tree. */ ReturnCode_t struct_to_str( const utilities::collections::TreeNode& node, std::string& struct_str) noexcept; /** - * TODO + * @brief Converts a tree with a \c TK_ENUM root to an IDL string. + * + * @param node The root node of the tree. + * @param enum_str The string representation of the tree. */ ReturnCode_t enum_to_str( const utilities::collections::TreeNode& node, std::string& enum_str) noexcept; /** - * TODO + * @brief Converts a tree with a \c TK_UNION root to an IDL string. + * + * @param node The root node of the tree. + * @param union_str The string representation of the tree. */ ReturnCode_t union_to_str( const utilities::collections::TreeNode& node, std::string& union_str) noexcept; /** - * TODO + * @brief Converts a simple tree to an IDL string. + * + * @param node The root node of the tree. + * @param node_str The string representation of the tree. */ ReturnCode_t node_to_str( const utilities::collections::TreeNode& node, diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index ef360f41bfc..6fce8475c92 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -92,7 +92,7 @@ ReturnCode_t dyn_type_to_tree( } std::string internal_str; - ret = type_kind_to_str(internal_type, internal_str); + ret = dyn_type_to_str(internal_type, internal_str); if (ret != RETCODE_OK) { @@ -117,7 +117,7 @@ ReturnCode_t dyn_type_to_tree( default: { std::string type_str; - ret = type_kind_to_str(type, type_str); + ret = dyn_type_to_str(type, type_str); if (ret != RETCODE_OK) { @@ -132,7 +132,7 @@ ReturnCode_t dyn_type_to_tree( return ret; } -ReturnCode_t type_kind_to_str( +ReturnCode_t dyn_type_to_str( const DynamicType::_ref_type& dyn_type, std::string& type_str) noexcept { @@ -285,7 +285,7 @@ ReturnCode_t array_kind_to_str( return ret; } - ret = type_kind_to_str(internal_type, array_str); + ret = dyn_type_to_str(internal_type, array_str); if (ret != RETCODE_OK) { @@ -330,7 +330,7 @@ ReturnCode_t sequence_kind_to_str( return ret; } - ret = type_kind_to_str(internal_type, sequence_str); + ret = dyn_type_to_str(internal_type, sequence_str); if (ret != RETCODE_OK) { @@ -386,7 +386,7 @@ ReturnCode_t map_kind_to_str( std::string key_str; const auto key_type = type_descriptor->key_element_type(); - ret = type_kind_to_str(key_type, key_str); + ret = dyn_type_to_str(key_type, key_str); if (ret != RETCODE_OK) { @@ -395,7 +395,7 @@ ReturnCode_t map_kind_to_str( std::string value_str; const auto value_type = type_descriptor->element_type(); - ret = type_kind_to_str(value_type, value_str); + ret = dyn_type_to_str(value_type, value_str); if (ret != RETCODE_OK) { @@ -489,8 +489,8 @@ ReturnCode_t container_size( ////////////////////////////// ReturnCode_t dyn_type_tree_to_idl( - const utilities::collections::TreeNode& parent_node, - std::string& dyn_type_idl) noexcept + const utilities::collections::TreeNode& root, + std::string& dyn_type_str) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -499,7 +499,7 @@ ReturnCode_t dyn_type_tree_to_idl( // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). // If it is, check if it is not yet written // If it is not, write it down - for (const auto& node : parent_node.all_nodes()) + for (const auto& node : root.all_nodes()) { if (types_written.find(node.info.type_kind_name) != types_written.end()) { @@ -535,21 +535,21 @@ ReturnCode_t dyn_type_tree_to_idl( return ret; } - dyn_type_idl += kind_str + "\n"; + dyn_type_str += kind_str + "\n"; types_written.insert(node.info.type_kind_name); } // Write struct parent node at last, after all its dependencies // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent std::string struct_str; - ret = struct_to_str(parent_node, struct_str); + ret = struct_to_str(root, struct_str); if (ret != RETCODE_OK) { return ret; } - dyn_type_idl += struct_str; + dyn_type_str += struct_str; return ret; } @@ -646,7 +646,7 @@ ReturnCode_t union_to_str( } std::string discriminant_type_str; - ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); + ret = dyn_type_to_str(type_descriptor->discriminator_type(), discriminant_type_str); if (ret != RETCODE_OK) { @@ -693,7 +693,7 @@ ReturnCode_t union_to_str( } std::string member_str; - ret = type_kind_to_str(member_descriptor->type(), member_str); + ret = dyn_type_to_str(member_descriptor->type(), member_str); if (ret != RETCODE_OK) { diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index edb0e446bd0..f42469b2d96 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -714,7 +714,7 @@ ReturnCode_t generate_dyn_type_schema_from_tree( ReturnCode_t idl_serialize( const traits::ref_type& dynamic_type, - std::string& idl_schema) noexcept + std::string& output) noexcept { // Create a tree representation of the dynamic type utilities::collections::TreeNode parent_type; @@ -726,7 +726,7 @@ ReturnCode_t idl_serialize( } // Serialize the tree to IDL - return dyn_type_tree_to_idl(parent_type, idl_schema); + return dyn_type_tree_to_idl(parent_type, output); } } // namespace dds From 1b50212a42878b551a85491463cd3fdbb5b92ce2 Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 19 Jun 2024 17:10:20 +0200 Subject: [PATCH 11/52] Tests - Dynamic Types to IDL Signed-off-by: tempate --- test/unittest/CMakeLists.txt | 1 + .../dds/xtypes/type_conversion/CMakeLists.txt | 48 ++ .../type_conversion/DynTypeToIdlTests.cpp | 86 ++ .../type_conversion/types/all_types.hpp | 174 ++++ .../types/idls/arrays_and_sequences.idl | 12 + .../types/idls/basic_array_struct.idl | 11 + .../types/idls/basic_struct.idl | 9 + .../types/idls/char_sequence.idl | 4 + .../types/idls/complex_nested_arrays.idl | 23 + .../types/idls/enum_struct.idl | 12 + .../types/idls/float_bounded_sequence.idl | 4 + .../types/idls/hello_world.idl | 5 + .../type_conversion/types/idls/map_struct.idl | 4 + .../types/idls/numeric_array.idl | 4 + .../types/idls/union_struct.idl | 15 + .../arrays_and_sequences.hpp | 445 ++++++++++ .../arrays_and_sequencesCdrAux.hpp | 53 ++ .../arrays_and_sequencesCdrAux.ipp | 218 +++++ .../arrays_and_sequencesPubSubTypes.cxx | 422 +++++++++ .../arrays_and_sequencesPubSubTypes.h | 224 +++++ .../arrays_and_sequencesTypeObjectSupport.cxx | 341 ++++++++ .../arrays_and_sequencesTypeObjectSupport.hpp | 68 ++ .../basic_array_struct/basic_array_struct.hpp | 386 +++++++++ .../basic_array_structCdrAux.hpp | 53 ++ .../basic_array_structCdrAux.ipp | 210 +++++ .../basic_array_structPubSubTypes.cxx | 422 +++++++++ .../basic_array_structPubSubTypes.h | 224 +++++ .../basic_array_structTypeObjectSupport.cxx | 251 ++++++ .../basic_array_structTypeObjectSupport.hpp | 68 ++ .../basic_struct/basic_struct.hpp | 311 +++++++ .../basic_struct/basic_structCdrAux.hpp | 53 ++ .../basic_struct/basic_structCdrAux.ipp | 194 +++++ .../basic_struct/basic_structPubSubTypes.cxx | 422 +++++++++ .../basic_struct/basic_structPubSubTypes.h | 224 +++++ .../basic_structTypeObjectSupport.cxx | 157 ++++ .../basic_structTypeObjectSupport.hpp | 68 ++ .../char_sequence/char_sequence.hpp | 190 ++++ .../char_sequence/char_sequenceCdrAux.hpp | 46 + .../char_sequence/char_sequenceCdrAux.ipp | 118 +++ .../char_sequencePubSubTypes.cxx | 229 +++++ .../char_sequence/char_sequencePubSubTypes.h | 133 +++ .../char_sequenceTypeObjectSupport.cxx | 132 +++ .../char_sequenceTypeObjectSupport.hpp | 56 ++ .../complex_nested_arrays.hpp | 760 ++++++++++++++++ .../complex_nested_arraysCdrAux.hpp | 67 ++ .../complex_nested_arraysCdrAux.ipp | 378 ++++++++ .../complex_nested_arraysPubSubTypes.cxx | 808 ++++++++++++++++++ .../complex_nested_arraysPubSubTypes.h | 406 +++++++++ ...complex_nested_arraysTypeObjectSupport.cxx | 493 +++++++++++ ...complex_nested_arraysTypeObjectSupport.hpp | 92 ++ .../type_objects/enum_struct/enum_struct.hpp | 225 +++++ .../enum_struct/enum_structCdrAux.hpp | 47 + .../enum_struct/enum_structCdrAux.ipp | 126 +++ .../enum_struct/enum_structPubSubTypes.cxx | 229 +++++ .../enum_struct/enum_structPubSubTypes.h | 133 +++ .../enum_structTypeObjectSupport.cxx | 185 ++++ .../enum_structTypeObjectSupport.hpp | 68 ++ .../float_bounded_sequence.hpp | 190 ++++ .../float_bounded_sequenceCdrAux.hpp | 46 + .../float_bounded_sequenceCdrAux.ipp | 118 +++ .../float_bounded_sequencePubSubTypes.cxx | 229 +++++ .../float_bounded_sequencePubSubTypes.h | 133 +++ ...loat_bounded_sequenceTypeObjectSupport.cxx | 132 +++ ...loat_bounded_sequenceTypeObjectSupport.hpp | 56 ++ .../type_objects/hello_world/hello_world.hpp | 227 +++++ .../hello_world/hello_worldCdrAux.hpp | 46 + .../hello_world/hello_worldCdrAux.ipp | 126 +++ .../hello_world/hello_worldPubSubTypes.cxx | 229 +++++ .../hello_world/hello_worldPubSubTypes.h | 133 +++ .../hello_worldTypeObjectSupport.cxx | 138 +++ .../hello_worldTypeObjectSupport.hpp | 56 ++ .../type_objects/map_struct/map_struct.hpp | 191 +++++ .../map_struct/map_structCdrAux.hpp | 46 + .../map_struct/map_structCdrAux.ipp | 118 +++ .../map_struct/map_structPubSubTypes.cxx | 229 +++++ .../map_struct/map_structPubSubTypes.h | 133 +++ .../map_structTypeObjectSupport.cxx | 167 ++++ .../map_structTypeObjectSupport.hpp | 56 ++ .../numeric_array/numeric_array.hpp | 189 ++++ .../numeric_array/numeric_arrayCdrAux.hpp | 46 + .../numeric_array/numeric_arrayCdrAux.ipp | 118 +++ .../numeric_arrayPubSubTypes.cxx | 229 +++++ .../numeric_array/numeric_arrayPubSubTypes.h | 133 +++ .../numeric_arrayTypeObjectSupport.cxx | 134 +++ .../numeric_arrayTypeObjectSupport.hpp | 56 ++ .../union_struct/union_struct.hpp | 676 +++++++++++++++ .../union_struct/union_structCdrAux.hpp | 47 + .../union_struct/union_structCdrAux.ipp | 277 ++++++ .../union_struct/union_structPubSubTypes.cxx | 229 +++++ .../union_struct/union_structPubSubTypes.h | 133 +++ .../union_structTypeObjectSupport.cxx | 291 +++++++ .../union_structTypeObjectSupport.hpp | 68 ++ 92 files changed, 15572 insertions(+) create mode 100644 test/unittest/dds/xtypes/type_conversion/CMakeLists.txt create mode 100644 test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/all_types.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp diff --git a/test/unittest/CMakeLists.txt b/test/unittest/CMakeLists.txt index dcf6151a3ba..6910ae040c8 100644 --- a/test/unittest/CMakeLists.txt +++ b/test/unittest/CMakeLists.txt @@ -24,6 +24,7 @@ add_subdirectory(dds/subscriber) add_subdirectory(dds/topic) add_subdirectory(dds/topic/DDSSQLFilter) add_subdirectory(dds/xtypes/serializers) +add_subdirectory(dds/xtypes/type_conversion) add_subdirectory(dds/xtypes/type_representation) add_subdirectory(logging) add_subdirectory(rtps/attributes) diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt new file mode 100644 index 00000000000..4c4549f6dd6 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -0,0 +1,48 @@ +# Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +set(RESOURCEDYNTYPETOIDLTESTS_SOURCE + DynTypeToIdlTests.cpp + ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/xtypes/utils.cpp) + +file(GLOB DATATYPE_SOURCES_CPP "types/type_objects/**/*.cpp") +file(GLOB DATATYPE_SOURCES_CXX "types/type_objects/**/*.cxx") +file(GLOB DATATYPE_SOURCES_IDL "types/idls/*.idl") + +set( + DATATYPE_SOURCES + ${DATATYPE_SOURCES_CPP} + ${DATATYPE_SOURCES_CXX} + ${DATATYPE_SOURCES_IDL} + ) + +if(WIN32) + add_definitions(-D_WIN32_WINNT=0x0601) +endif() + +add_executable(DynTypeToIdlTests ${RESOURCEDYNTYPETOIDLTESTS_SOURCE} ${DATATYPE_SOURCES}) +target_compile_definitions(DynTypeToIdlTests PRIVATE + $<$>,$>:__DEBUG> + $<$:__INTERNALDEBUG> # Internal debug activated. + ) +target_include_directories(DynTypeToIdlTests PRIVATE + ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include + ${PROJECT_SOURCE_DIR}/src/cpp + ) +target_link_libraries(DynTypeToIdlTests + fastcdr + fastdds + GTest::gtest + ${CMAKE_DL_LIBS}) +gtest_discover_tests(DynTypeToIdlTests SOURCES ${TYPEOBJECTUTILSTESTS_SOURCE}) diff --git a/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp b/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp new file mode 100644 index 00000000000..15eb1ba9e90 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp @@ -0,0 +1,86 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +#include + +#include +#include +#include + +#include "types/all_types.hpp" + +using namespace eprosima; + +class DynTypeToIdlTests : public ::testing::TestWithParam +{ +}; + +/** + * Verify that the IDL serialization of a DynamicType matches the IDL file that defined the type. + * + * CASES: + * - Verify that the IDL file was opened successfully. + * - Verify that the IDL serialization finished successfully. + * - Verify that the two IDLs match. + */ +TEST_P(DynTypeToIdlTests, msg_schema_generation) +{ + const test::SupportedType type = GetParam(); + + // Read the IDL file as a string + const std::string full_path{"/home/daniel/Documents/eprosima/dynamic_type_idl/src/fastdds/test/unittest/dds/xtypes/type_conversion/types/idls/"}; + const auto file_name = full_path + to_string(type) + ".idl"; + + std::ifstream file(file_name); + + ASSERT_TRUE(file.is_open()); + + const std::string idl_file{std::istreambuf_iterator(file), std::istreambuf_iterator()}; + + // Get Dynamic type + const fastdds::dds::DynamicType::_ref_type dyn_type = test::get_dynamic_type(type); + + // Serialize DynamicType to IDL + std::string idl_serialization; + ASSERT_EQ(fastdds::dds::idl_serialize(dyn_type, idl_serialization), fastdds::dds::RETCODE_OK); + + // Compare IDLs + ASSERT_EQ(idl_file, idl_serialization); +} + +INSTANTIATE_TEST_SUITE_P(DynTypeToIdlTests, DynTypeToIdlTests, ::testing::Values( + test::SupportedType::hello_world, + test::SupportedType::numeric_array, + test::SupportedType::char_sequence, + test::SupportedType::basic_struct, + test::SupportedType::basic_array_struct, + test::SupportedType::float_bounded_sequence, + test::SupportedType::arrays_and_sequences, + test::SupportedType::complex_nested_arrays, + test::SupportedType::enum_struct, + test::SupportedType::union_struct, + test::SupportedType::map_struct + )); + +int main( + int argc, + char** argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp new file mode 100644 index 00000000000..677f1206728 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -0,0 +1,174 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @file all_types.hpp + */ + +/* + * USEFUL COMMAND + * + * for TYPE in hello_world numeric_array char_sequence basic_struct basic_array_struct float_bounded_sequence arrays_and_sequences complex_nested_arrays; do ${FASTDDSGEN_WS}/scripts/fastddsgen -replace -d ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/type_objects/ -typeobject -cs ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/idls/${TYPE}.idl; done + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" +#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" + +#include "type_objects/basic_array_struct/basic_array_struct.hpp" +#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" + +#include "type_objects/basic_struct/basic_struct.hpp" +#include "type_objects/basic_struct/basic_structPubSubTypes.h" + +#include "type_objects/char_sequence/char_sequence.hpp" +#include "type_objects/char_sequence/char_sequencePubSubTypes.h" + +#include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" +#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h" + +#include "type_objects/enum_struct/enum_struct.hpp" +#include "type_objects/enum_struct/enum_structPubSubTypes.h" + +#include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" +#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" + +#include "type_objects/hello_world/hello_world.hpp" +#include "type_objects/hello_world/hello_worldPubSubTypes.h" + +#include "type_objects/map_struct/map_struct.hpp" +#include "type_objects/map_struct/map_structPubSubTypes.h" + +#include "type_objects/numeric_array/numeric_array.hpp" +#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" + +#include "type_objects/union_struct/union_struct.hpp" +#include "type_objects/union_struct/union_structPubSubTypes.h" + + +namespace test { + +enum SupportedType +{ + hello_world, + numeric_array, + char_sequence, + basic_struct, + basic_array_struct, + float_bounded_sequence, + arrays_and_sequences, + complex_nested_arrays, + enum_struct, + union_struct, // NOTE: default case currently not supported in dynamic types + map_struct +}; + +std::string to_string(const SupportedType& type) +{ + switch (type) + { + case SupportedType::hello_world: + return "hello_world"; + case SupportedType::numeric_array: + return "numeric_array"; + case SupportedType::char_sequence: + return "char_sequence"; + case SupportedType::basic_struct: + return "basic_struct"; + case SupportedType::basic_array_struct: + return "basic_array_struct"; + case SupportedType::float_bounded_sequence: + return "float_bounded_sequence"; + case SupportedType::arrays_and_sequences: + return "arrays_and_sequences"; + case SupportedType::complex_nested_arrays: + return "complex_nested_arrays"; + case SupportedType::enum_struct: + return "enum_struct"; + case SupportedType::union_struct: + return "union_struct"; + case SupportedType::map_struct: + return "map_struct"; + default: + return "invalid"; + } +} + + +eprosima::fastdds::dds::DynamicType::_ref_type get_dynamic_type( // traits::ref_type + SupportedType dyn_type) +{ + // Register the type + eprosima::fastdds::dds::TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); + type_arrays_and_sequences->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); + type_basic_array_struct->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_basic_struct(new basic_structPubSubType()); + type_basic_struct->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); + type_complex_nested_arrays->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_char_sequence(new char_sequencePubSubType()); + type_char_sequence->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_enum_struct(new enum_structPubSubType()); + type_enum_struct->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); + type_float_bounded_sequence->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_hello_world(new hello_worldPubSubType()); + type_hello_world->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_map_struct(new map_structPubSubType()); + type_map_struct->register_type_object_representation(); + + eprosima::fastdds::dds::TypeSupport type_numeric_array(new numeric_arrayPubSubType()); + type_numeric_array->register_type_object_representation(); + + + eprosima::fastdds::dds::TypeSupport type_union_struct(new union_structPubSubType()); + type_union_struct->register_type_object_representation(); + + auto type_name = to_string(dyn_type); + + eprosima::fastdds::dds::xtypes::TypeObjectPair type_objs; + if (eprosima::fastdds::dds::RETCODE_OK == eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects( + type_name, + type_objs)) + { + return eprosima::fastdds::dds::DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object(type_objs.complete_type_object)->build(); + } + + else + { + // throw eprosima::utils::InconsistencyException("No Type Object"); + } + + return nullptr; +} + +} /* namespace test */ diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl new file mode 100644 index 00000000000..5d9f9819408 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl @@ -0,0 +1,12 @@ +struct AnInternalObject +{ + float x; + boolean positive; +}; + +struct arrays_and_sequences +{ + sequence unlimited_vector; + sequence limited_vector; + AnInternalObject limited_array[10]; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl new file mode 100644 index 00000000000..b81e59565ec --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl @@ -0,0 +1,11 @@ +struct TheOtherObjectInArray +{ + long some_num; + boolean positive; +}; + +struct basic_array_struct +{ + unsigned long index; + TheOtherObjectInArray sub_structs[5]; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl new file mode 100644 index 00000000000..da2ea1bbe0a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl @@ -0,0 +1,9 @@ +struct TheOtherObject +{ + long some_num; +}; + +struct basic_struct +{ + TheOtherObject sub_struct; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl new file mode 100644 index 00000000000..0abf7dd8bb2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl @@ -0,0 +1,4 @@ +struct char_sequence +{ + sequence chars; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl new file mode 100644 index 00000000000..b4eca21b735 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl @@ -0,0 +1,23 @@ +struct ThirdLevelElement +{ + double x; + double y; +}; + +struct SecondLevelElement +{ + ThirdLevelElement an_element_alone; + sequence a_limited_other_value; +}; + +struct FirstLevelElement +{ + string useless_name; + sequence sub; + ThirdLevelElement an_element_alone; +}; + +struct complex_nested_arrays +{ + FirstLevelElement array_of_elements[3]; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl new file mode 100644 index 00000000000..c40eae6ea45 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl @@ -0,0 +1,12 @@ +enum ColorEnum +{ + RED, + GREEN, + BLUE +}; + +struct enum_struct +{ + unsigned long index; + ColorEnum enum_value; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl new file mode 100644 index 00000000000..b297df865e0 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl @@ -0,0 +1,4 @@ +struct float_bounded_sequence +{ + sequence numbers; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl new file mode 100644 index 00000000000..d82036d8963 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl @@ -0,0 +1,5 @@ +struct hello_world +{ + unsigned long index; + string message; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl new file mode 100644 index 00000000000..d4d19acbdec --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl @@ -0,0 +1,4 @@ +struct map_struct +{ + map my_map; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl new file mode 100644 index 00000000000..814abd597d6 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl @@ -0,0 +1,4 @@ +struct numeric_array +{ + long points[3]; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl new file mode 100644 index 00000000000..3967f961a41 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl @@ -0,0 +1,15 @@ +union MyUnion switch (long) +{ + case 1: + octet octet_value; + case 2: + long long_value; + case 3: + string string_value; +}; + +struct union_struct +{ + unsigned long index; + MyUnion union_value; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp new file mode 100644 index 00000000000..eff9b5ef6e7 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp @@ -0,0 +1,445 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequences.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ +#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ + +#include +#include +#include +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(ARRAYS_AND_SEQUENCES_SOURCE) +#define ARRAYS_AND_SEQUENCES_DllAPI __declspec( dllexport ) +#else +#define ARRAYS_AND_SEQUENCES_DllAPI __declspec( dllimport ) +#endif // ARRAYS_AND_SEQUENCES_SOURCE +#else +#define ARRAYS_AND_SEQUENCES_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define ARRAYS_AND_SEQUENCES_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure AnInternalObject defined by the user in the IDL file. + * @ingroup arrays_and_sequences + */ +class AnInternalObject +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport AnInternalObject() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~AnInternalObject() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object AnInternalObject that will be copied. + */ + eProsima_user_DllExport AnInternalObject( + const AnInternalObject& x) + { + m_x = x.m_x; + + m_positive = x.m_positive; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object AnInternalObject that will be copied. + */ + eProsima_user_DllExport AnInternalObject( + AnInternalObject&& x) noexcept + { + m_x = x.m_x; + m_positive = x.m_positive; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object AnInternalObject that will be copied. + */ + eProsima_user_DllExport AnInternalObject& operator =( + const AnInternalObject& x) + { + + m_x = x.m_x; + + m_positive = x.m_positive; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object AnInternalObject that will be copied. + */ + eProsima_user_DllExport AnInternalObject& operator =( + AnInternalObject&& x) noexcept + { + + m_x = x.m_x; + m_positive = x.m_positive; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x AnInternalObject object to compare. + */ + eProsima_user_DllExport bool operator ==( + const AnInternalObject& x) const + { + return (m_x == x.m_x && + m_positive == x.m_positive); + } + + /*! + * @brief Comparison operator. + * @param x AnInternalObject object to compare. + */ + eProsima_user_DllExport bool operator !=( + const AnInternalObject& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member x + * @param _x New value for member x + */ + eProsima_user_DllExport void x( + float _x) + { + m_x = _x; + } + + /*! + * @brief This function returns the value of member x + * @return Value of member x + */ + eProsima_user_DllExport float x() const + { + return m_x; + } + + /*! + * @brief This function returns a reference to member x + * @return Reference to member x + */ + eProsima_user_DllExport float& x() + { + return m_x; + } + + + /*! + * @brief This function sets a value in member positive + * @param _positive New value for member positive + */ + eProsima_user_DllExport void positive( + bool _positive) + { + m_positive = _positive; + } + + /*! + * @brief This function returns the value of member positive + * @return Value of member positive + */ + eProsima_user_DllExport bool positive() const + { + return m_positive; + } + + /*! + * @brief This function returns a reference to member positive + * @return Reference to member positive + */ + eProsima_user_DllExport bool& positive() + { + return m_positive; + } + + + +private: + + float m_x{0.0}; + bool m_positive{false}; + +}; +/*! + * @brief This class represents the structure arrays_and_sequences defined by the user in the IDL file. + * @ingroup arrays_and_sequences + */ +class arrays_and_sequences +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport arrays_and_sequences() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~arrays_and_sequences() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object arrays_and_sequences that will be copied. + */ + eProsima_user_DllExport arrays_and_sequences( + const arrays_and_sequences& x) + { + m_unlimited_vector = x.m_unlimited_vector; + + m_limited_vector = x.m_limited_vector; + + m_limited_array = x.m_limited_array; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object arrays_and_sequences that will be copied. + */ + eProsima_user_DllExport arrays_and_sequences( + arrays_and_sequences&& x) noexcept + { + m_unlimited_vector = std::move(x.m_unlimited_vector); + m_limited_vector = std::move(x.m_limited_vector); + m_limited_array = std::move(x.m_limited_array); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object arrays_and_sequences that will be copied. + */ + eProsima_user_DllExport arrays_and_sequences& operator =( + const arrays_and_sequences& x) + { + + m_unlimited_vector = x.m_unlimited_vector; + + m_limited_vector = x.m_limited_vector; + + m_limited_array = x.m_limited_array; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object arrays_and_sequences that will be copied. + */ + eProsima_user_DllExport arrays_and_sequences& operator =( + arrays_and_sequences&& x) noexcept + { + + m_unlimited_vector = std::move(x.m_unlimited_vector); + m_limited_vector = std::move(x.m_limited_vector); + m_limited_array = std::move(x.m_limited_array); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x arrays_and_sequences object to compare. + */ + eProsima_user_DllExport bool operator ==( + const arrays_and_sequences& x) const + { + return (m_unlimited_vector == x.m_unlimited_vector && + m_limited_vector == x.m_limited_vector && + m_limited_array == x.m_limited_array); + } + + /*! + * @brief Comparison operator. + * @param x arrays_and_sequences object to compare. + */ + eProsima_user_DllExport bool operator !=( + const arrays_and_sequences& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member unlimited_vector + * @param _unlimited_vector New value to be copied in member unlimited_vector + */ + eProsima_user_DllExport void unlimited_vector( + const std::vector& _unlimited_vector) + { + m_unlimited_vector = _unlimited_vector; + } + + /*! + * @brief This function moves the value in member unlimited_vector + * @param _unlimited_vector New value to be moved in member unlimited_vector + */ + eProsima_user_DllExport void unlimited_vector( + std::vector&& _unlimited_vector) + { + m_unlimited_vector = std::move(_unlimited_vector); + } + + /*! + * @brief This function returns a constant reference to member unlimited_vector + * @return Constant reference to member unlimited_vector + */ + eProsima_user_DllExport const std::vector& unlimited_vector() const + { + return m_unlimited_vector; + } + + /*! + * @brief This function returns a reference to member unlimited_vector + * @return Reference to member unlimited_vector + */ + eProsima_user_DllExport std::vector& unlimited_vector() + { + return m_unlimited_vector; + } + + + /*! + * @brief This function copies the value in member limited_vector + * @param _limited_vector New value to be copied in member limited_vector + */ + eProsima_user_DllExport void limited_vector( + const std::vector& _limited_vector) + { + m_limited_vector = _limited_vector; + } + + /*! + * @brief This function moves the value in member limited_vector + * @param _limited_vector New value to be moved in member limited_vector + */ + eProsima_user_DllExport void limited_vector( + std::vector&& _limited_vector) + { + m_limited_vector = std::move(_limited_vector); + } + + /*! + * @brief This function returns a constant reference to member limited_vector + * @return Constant reference to member limited_vector + */ + eProsima_user_DllExport const std::vector& limited_vector() const + { + return m_limited_vector; + } + + /*! + * @brief This function returns a reference to member limited_vector + * @return Reference to member limited_vector + */ + eProsima_user_DllExport std::vector& limited_vector() + { + return m_limited_vector; + } + + + /*! + * @brief This function copies the value in member limited_array + * @param _limited_array New value to be copied in member limited_array + */ + eProsima_user_DllExport void limited_array( + const std::array& _limited_array) + { + m_limited_array = _limited_array; + } + + /*! + * @brief This function moves the value in member limited_array + * @param _limited_array New value to be moved in member limited_array + */ + eProsima_user_DllExport void limited_array( + std::array&& _limited_array) + { + m_limited_array = std::move(_limited_array); + } + + /*! + * @brief This function returns a constant reference to member limited_array + * @return Constant reference to member limited_array + */ + eProsima_user_DllExport const std::array& limited_array() const + { + return m_limited_array; + } + + /*! + * @brief This function returns a reference to member limited_array + * @return Reference to member limited_array + */ + eProsima_user_DllExport std::array& limited_array() + { + return m_limited_array; + } + + + +private: + + std::vector m_unlimited_vector; + std::vector m_limited_vector; + std::array m_limited_array; + +}; + +#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp new file mode 100644 index 00000000000..a8be1936252 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp @@ -0,0 +1,53 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ + +#include "arrays_and_sequences.hpp" + +constexpr uint32_t arrays_and_sequences_max_cdr_typesize {261UL}; +constexpr uint32_t arrays_and_sequences_max_key_cdr_typesize {0UL}; + +constexpr uint32_t AnInternalObject_max_cdr_typesize {9UL}; +constexpr uint32_t AnInternalObject_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const AnInternalObject& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const arrays_and_sequences& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp new file mode 100644 index 00000000000..d5d27a39065 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp @@ -0,0 +1,218 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ + +#include "arrays_and_sequencesCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const AnInternalObject& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.x(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.positive(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const AnInternalObject& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.x() + << eprosima::fastcdr::MemberId(1) << data.positive() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + AnInternalObject& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.x(); + break; + + case 1: + dcdr >> data.positive(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const AnInternalObject& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const arrays_and_sequences& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.unlimited_vector(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.limited_vector(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.limited_array(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const arrays_and_sequences& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.unlimited_vector() + << eprosima::fastcdr::MemberId(1) << data.limited_vector() + << eprosima::fastcdr::MemberId(2) << data.limited_array() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + arrays_and_sequences& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.unlimited_vector(); + break; + + case 1: + dcdr >> data.limited_vector(); + break; + + case 2: + dcdr >> data.limited_array(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const arrays_and_sequences& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx new file mode 100644 index 00000000000..43aa37c67a8 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx @@ -0,0 +1,422 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "arrays_and_sequencesPubSubTypes.h" + +#include +#include + +#include "arrays_and_sequencesCdrAux.hpp" +#include "arrays_and_sequencesTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +AnInternalObjectPubSubType::AnInternalObjectPubSubType() +{ + setName("AnInternalObject"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(AnInternalObject::getMaxCdrSerializedSize()); +#else + AnInternalObject_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = AnInternalObject_max_key_cdr_typesize > 16 ? AnInternalObject_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +AnInternalObjectPubSubType::~AnInternalObjectPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool AnInternalObjectPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + AnInternalObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool AnInternalObjectPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + AnInternalObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function AnInternalObjectPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* AnInternalObjectPubSubType::createData() +{ + return reinterpret_cast(new AnInternalObject()); +} + +void AnInternalObjectPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool AnInternalObjectPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + AnInternalObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + AnInternalObject_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || AnInternalObject_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void AnInternalObjectPubSubType::register_type_object_representation() +{ + register_AnInternalObject_type_identifier(type_identifiers_); +} + +arrays_and_sequencesPubSubType::arrays_and_sequencesPubSubType() +{ + setName("arrays_and_sequences"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(arrays_and_sequences::getMaxCdrSerializedSize()); +#else + arrays_and_sequences_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = arrays_and_sequences_max_key_cdr_typesize > 16 ? arrays_and_sequences_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +arrays_and_sequencesPubSubType::~arrays_and_sequencesPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool arrays_and_sequencesPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + arrays_and_sequences* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool arrays_and_sequencesPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + arrays_and_sequences* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function arrays_and_sequencesPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* arrays_and_sequencesPubSubType::createData() +{ + return reinterpret_cast(new arrays_and_sequences()); +} + +void arrays_and_sequencesPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool arrays_and_sequencesPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + arrays_and_sequences* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + arrays_and_sequences_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || arrays_and_sequences_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void arrays_and_sequencesPubSubType::register_type_object_representation() +{ + register_arrays_and_sequences_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "arrays_and_sequencesCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h new file mode 100644 index 00000000000..e3642121d59 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h @@ -0,0 +1,224 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "arrays_and_sequences.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated arrays_and_sequences is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type AnInternalObject defined by the user in the IDL file. + * @ingroup arrays_and_sequences + */ +class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef AnInternalObject type; + + eProsima_user_DllExport AnInternalObjectPubSubType(); + + eProsima_user_DllExport ~AnInternalObjectPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type arrays_and_sequences defined by the user in the IDL file. + * @ingroup arrays_and_sequences + */ +class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef arrays_and_sequences type; + + eProsima_user_DllExport arrays_and_sequencesPubSubType(); + + eProsima_user_DllExport ~arrays_and_sequencesPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx new file mode 100644 index 00000000000..06defd218d6 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx @@ -0,0 +1,341 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "arrays_and_sequencesTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "arrays_and_sequences.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_AnInternalObject_type_identifier( + TypeIdentifierPair& type_ids_AnInternalObject) +{ + + ReturnCode_t return_code_AnInternalObject {eprosima::fastdds::dds::RETCODE_OK}; + return_code_AnInternalObject = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AnInternalObject", type_ids_AnInternalObject); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_AnInternalObject) + { + StructTypeFlag struct_flags_AnInternalObject = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_AnInternalObject = "AnInternalObject"; + eprosima::fastcdr::optional type_ann_builtin_AnInternalObject; + eprosima::fastcdr::optional ann_custom_AnInternalObject; + CompleteTypeDetail detail_AnInternalObject = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_AnInternalObject, ann_custom_AnInternalObject, type_name_AnInternalObject.to_string()); + CompleteStructHeader header_AnInternalObject; + header_AnInternalObject = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AnInternalObject); + CompleteStructMemberSeq member_seq_AnInternalObject; + { + TypeIdentifierPair type_ids_x; + ReturnCode_t return_code_x {eprosima::fastdds::dds::RETCODE_OK}; + return_code_x = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_float", type_ids_x); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_x) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "x Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_x = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_x = 0x00000000; + bool common_x_ec {false}; + CommonStructMember common_x {TypeObjectUtils::build_common_struct_member(member_id_x, member_flags_x, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x, common_x_ec))}; + if (!common_x_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x member TypeIdentifier inconsistent."); + return; + } + MemberName name_x = "x"; + eprosima::fastcdr::optional member_ann_builtin_x; + ann_custom_AnInternalObject.reset(); + CompleteMemberDetail detail_x = TypeObjectUtils::build_complete_member_detail(name_x, member_ann_builtin_x, ann_custom_AnInternalObject); + CompleteStructMember member_x = TypeObjectUtils::build_complete_struct_member(common_x, detail_x); + TypeObjectUtils::add_complete_struct_member(member_seq_AnInternalObject, member_x); + } + { + TypeIdentifierPair type_ids_positive; + ReturnCode_t return_code_positive {eprosima::fastdds::dds::RETCODE_OK}; + return_code_positive = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_positive); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_positive) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "positive Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_positive = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_positive = 0x00000001; + bool common_positive_ec {false}; + CommonStructMember common_positive {TypeObjectUtils::build_common_struct_member(member_id_positive, member_flags_positive, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_positive, common_positive_ec))}; + if (!common_positive_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure positive member TypeIdentifier inconsistent."); + return; + } + MemberName name_positive = "positive"; + eprosima::fastcdr::optional member_ann_builtin_positive; + ann_custom_AnInternalObject.reset(); + CompleteMemberDetail detail_positive = TypeObjectUtils::build_complete_member_detail(name_positive, member_ann_builtin_positive, ann_custom_AnInternalObject); + CompleteStructMember member_positive = TypeObjectUtils::build_complete_struct_member(common_positive, detail_positive); + TypeObjectUtils::add_complete_struct_member(member_seq_AnInternalObject, member_positive); + } + CompleteStructType struct_type_AnInternalObject = TypeObjectUtils::build_complete_struct_type(struct_flags_AnInternalObject, header_AnInternalObject, member_seq_AnInternalObject); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_AnInternalObject, type_name_AnInternalObject.to_string(), type_ids_AnInternalObject)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "AnInternalObject already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_arrays_and_sequences_type_identifier( + TypeIdentifierPair& type_ids_arrays_and_sequences) +{ + + ReturnCode_t return_code_arrays_and_sequences {eprosima::fastdds::dds::RETCODE_OK}; + return_code_arrays_and_sequences = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "arrays_and_sequences", type_ids_arrays_and_sequences); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_arrays_and_sequences) + { + StructTypeFlag struct_flags_arrays_and_sequences = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_arrays_and_sequences = "arrays_and_sequences"; + eprosima::fastcdr::optional type_ann_builtin_arrays_and_sequences; + eprosima::fastcdr::optional ann_custom_arrays_and_sequences; + CompleteTypeDetail detail_arrays_and_sequences = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_arrays_and_sequences, ann_custom_arrays_and_sequences, type_name_arrays_and_sequences.to_string()); + CompleteStructHeader header_arrays_and_sequences; + header_arrays_and_sequences = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_arrays_and_sequences); + CompleteStructMemberSeq member_seq_arrays_and_sequences; + { + TypeIdentifierPair type_ids_unlimited_vector; + ReturnCode_t return_code_unlimited_vector {eprosima::fastdds::dds::RETCODE_OK}; + return_code_unlimited_vector = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_AnInternalObject_unbounded", type_ids_unlimited_vector); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_unlimited_vector) + { + return_code_unlimited_vector = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AnInternalObject", type_ids_unlimited_vector); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_unlimited_vector) + { + ::register_AnInternalObject_type_identifier(type_ids_unlimited_vector); + } + bool element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_AnInternalObject_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unlimited_vector, element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_AnInternalObject_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_unlimited_vector.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_AnInternalObject_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_AnInternalObject_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_AnInternalObject_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_AnInternalObject_unbounded, element_flags_anonymous_sequence_AnInternalObject_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_AnInternalObject_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_AnInternalObject_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_AnInternalObject_unbounded", type_ids_unlimited_vector)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_AnInternalObject_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_unlimited_vector = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_unlimited_vector = 0x00000000; + bool common_unlimited_vector_ec {false}; + CommonStructMember common_unlimited_vector {TypeObjectUtils::build_common_struct_member(member_id_unlimited_vector, member_flags_unlimited_vector, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unlimited_vector, common_unlimited_vector_ec))}; + if (!common_unlimited_vector_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unlimited_vector member TypeIdentifier inconsistent."); + return; + } + MemberName name_unlimited_vector = "unlimited_vector"; + eprosima::fastcdr::optional member_ann_builtin_unlimited_vector; + ann_custom_arrays_and_sequences.reset(); + CompleteMemberDetail detail_unlimited_vector = TypeObjectUtils::build_complete_member_detail(name_unlimited_vector, member_ann_builtin_unlimited_vector, ann_custom_arrays_and_sequences); + CompleteStructMember member_unlimited_vector = TypeObjectUtils::build_complete_struct_member(common_unlimited_vector, detail_unlimited_vector); + TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_unlimited_vector); + } + { + TypeIdentifierPair type_ids_limited_vector; + ReturnCode_t return_code_limited_vector {eprosima::fastdds::dds::RETCODE_OK}; + return_code_limited_vector = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_AnInternalObject_10", type_ids_limited_vector); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_vector) + { + return_code_limited_vector = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AnInternalObject", type_ids_limited_vector); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_vector) + { + ::register_AnInternalObject_type_identifier(type_ids_limited_vector); + } + bool element_identifier_anonymous_sequence_AnInternalObject_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_AnInternalObject_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_vector, element_identifier_anonymous_sequence_AnInternalObject_10_ec))}; + if (!element_identifier_anonymous_sequence_AnInternalObject_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_AnInternalObject_10 = EK_COMPLETE; + if (TK_NONE == type_ids_limited_vector.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_AnInternalObject_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_AnInternalObject_10 = 0; + PlainCollectionHeader header_anonymous_sequence_AnInternalObject_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_AnInternalObject_10, element_flags_anonymous_sequence_AnInternalObject_10); + { + SBound bound = static_cast(10); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_AnInternalObject_10, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_AnInternalObject_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_AnInternalObject_10", type_ids_limited_vector)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_AnInternalObject_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_limited_vector = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_limited_vector = 0x00000001; + bool common_limited_vector_ec {false}; + CommonStructMember common_limited_vector {TypeObjectUtils::build_common_struct_member(member_id_limited_vector, member_flags_limited_vector, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_vector, common_limited_vector_ec))}; + if (!common_limited_vector_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure limited_vector member TypeIdentifier inconsistent."); + return; + } + MemberName name_limited_vector = "limited_vector"; + eprosima::fastcdr::optional member_ann_builtin_limited_vector; + ann_custom_arrays_and_sequences.reset(); + CompleteMemberDetail detail_limited_vector = TypeObjectUtils::build_complete_member_detail(name_limited_vector, member_ann_builtin_limited_vector, ann_custom_arrays_and_sequences); + CompleteStructMember member_limited_vector = TypeObjectUtils::build_complete_struct_member(common_limited_vector, detail_limited_vector); + TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_limited_vector); + } + { + TypeIdentifierPair type_ids_limited_array; + ReturnCode_t return_code_limited_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_limited_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_AnInternalObject_10", type_ids_limited_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_array) + { + return_code_limited_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AnInternalObject", type_ids_limited_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_array) + { + ::register_AnInternalObject_type_identifier(type_ids_limited_array); + } + bool element_identifier_anonymous_array_AnInternalObject_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_AnInternalObject_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_array, element_identifier_anonymous_array_AnInternalObject_10_ec))}; + if (!element_identifier_anonymous_array_AnInternalObject_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_AnInternalObject_10 = EK_COMPLETE; + if (TK_NONE == type_ids_limited_array.type_identifier2()._d()) + { + equiv_kind_anonymous_array_AnInternalObject_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_AnInternalObject_10 = 0; + PlainCollectionHeader header_anonymous_array_AnInternalObject_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_AnInternalObject_10, element_flags_anonymous_array_AnInternalObject_10); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_AnInternalObject_10, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_AnInternalObject_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_AnInternalObject_10", type_ids_limited_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_AnInternalObject_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_limited_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_limited_array = 0x00000002; + bool common_limited_array_ec {false}; + CommonStructMember common_limited_array {TypeObjectUtils::build_common_struct_member(member_id_limited_array, member_flags_limited_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_array, common_limited_array_ec))}; + if (!common_limited_array_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure limited_array member TypeIdentifier inconsistent."); + return; + } + MemberName name_limited_array = "limited_array"; + eprosima::fastcdr::optional member_ann_builtin_limited_array; + ann_custom_arrays_and_sequences.reset(); + CompleteMemberDetail detail_limited_array = TypeObjectUtils::build_complete_member_detail(name_limited_array, member_ann_builtin_limited_array, ann_custom_arrays_and_sequences); + CompleteStructMember member_limited_array = TypeObjectUtils::build_complete_struct_member(common_limited_array, detail_limited_array); + TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_limited_array); + } + CompleteStructType struct_type_arrays_and_sequences = TypeObjectUtils::build_complete_struct_type(struct_flags_arrays_and_sequences, header_arrays_and_sequences, member_seq_arrays_and_sequences); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_arrays_and_sequences, type_name_arrays_and_sequences.to_string(), type_ids_arrays_and_sequences)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "arrays_and_sequences already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp new file mode 100644 index 00000000000..6f6fb0541fd --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file arrays_and_sequencesTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register AnInternalObject related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_AnInternalObject_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register arrays_and_sequences related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_arrays_and_sequences_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp new file mode 100644 index 00000000000..bd064fe71c1 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp @@ -0,0 +1,386 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ + +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(BASIC_ARRAY_STRUCT_SOURCE) +#define BASIC_ARRAY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define BASIC_ARRAY_STRUCT_DllAPI __declspec( dllimport ) +#endif // BASIC_ARRAY_STRUCT_SOURCE +#else +#define BASIC_ARRAY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define BASIC_ARRAY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure TheOtherObjectInArray defined by the user in the IDL file. + * @ingroup basic_array_struct + */ +class TheOtherObjectInArray +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport TheOtherObjectInArray() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~TheOtherObjectInArray() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object TheOtherObjectInArray that will be copied. + */ + eProsima_user_DllExport TheOtherObjectInArray( + const TheOtherObjectInArray& x) + { + m_some_num = x.m_some_num; + + m_positive = x.m_positive; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object TheOtherObjectInArray that will be copied. + */ + eProsima_user_DllExport TheOtherObjectInArray( + TheOtherObjectInArray&& x) noexcept + { + m_some_num = x.m_some_num; + m_positive = x.m_positive; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object TheOtherObjectInArray that will be copied. + */ + eProsima_user_DllExport TheOtherObjectInArray& operator =( + const TheOtherObjectInArray& x) + { + + m_some_num = x.m_some_num; + + m_positive = x.m_positive; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object TheOtherObjectInArray that will be copied. + */ + eProsima_user_DllExport TheOtherObjectInArray& operator =( + TheOtherObjectInArray&& x) noexcept + { + + m_some_num = x.m_some_num; + m_positive = x.m_positive; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x TheOtherObjectInArray object to compare. + */ + eProsima_user_DllExport bool operator ==( + const TheOtherObjectInArray& x) const + { + return (m_some_num == x.m_some_num && + m_positive == x.m_positive); + } + + /*! + * @brief Comparison operator. + * @param x TheOtherObjectInArray object to compare. + */ + eProsima_user_DllExport bool operator !=( + const TheOtherObjectInArray& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member some_num + * @param _some_num New value for member some_num + */ + eProsima_user_DllExport void some_num( + int32_t _some_num) + { + m_some_num = _some_num; + } + + /*! + * @brief This function returns the value of member some_num + * @return Value of member some_num + */ + eProsima_user_DllExport int32_t some_num() const + { + return m_some_num; + } + + /*! + * @brief This function returns a reference to member some_num + * @return Reference to member some_num + */ + eProsima_user_DllExport int32_t& some_num() + { + return m_some_num; + } + + + /*! + * @brief This function sets a value in member positive + * @param _positive New value for member positive + */ + eProsima_user_DllExport void positive( + bool _positive) + { + m_positive = _positive; + } + + /*! + * @brief This function returns the value of member positive + * @return Value of member positive + */ + eProsima_user_DllExport bool positive() const + { + return m_positive; + } + + /*! + * @brief This function returns a reference to member positive + * @return Reference to member positive + */ + eProsima_user_DllExport bool& positive() + { + return m_positive; + } + + + +private: + + int32_t m_some_num{0}; + bool m_positive{false}; + +}; +/*! + * @brief This class represents the structure basic_array_struct defined by the user in the IDL file. + * @ingroup basic_array_struct + */ +class basic_array_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport basic_array_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~basic_array_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object basic_array_struct that will be copied. + */ + eProsima_user_DllExport basic_array_struct( + const basic_array_struct& x) + { + m_index = x.m_index; + + m_sub_structs = x.m_sub_structs; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object basic_array_struct that will be copied. + */ + eProsima_user_DllExport basic_array_struct( + basic_array_struct&& x) noexcept + { + m_index = x.m_index; + m_sub_structs = std::move(x.m_sub_structs); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object basic_array_struct that will be copied. + */ + eProsima_user_DllExport basic_array_struct& operator =( + const basic_array_struct& x) + { + + m_index = x.m_index; + + m_sub_structs = x.m_sub_structs; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object basic_array_struct that will be copied. + */ + eProsima_user_DllExport basic_array_struct& operator =( + basic_array_struct&& x) noexcept + { + + m_index = x.m_index; + m_sub_structs = std::move(x.m_sub_structs); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x basic_array_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const basic_array_struct& x) const + { + return (m_index == x.m_index && + m_sub_structs == x.m_sub_structs); + } + + /*! + * @brief Comparison operator. + * @param x basic_array_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const basic_array_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member index + * @param _index New value for member index + */ + eProsima_user_DllExport void index( + uint32_t _index) + { + m_index = _index; + } + + /*! + * @brief This function returns the value of member index + * @return Value of member index + */ + eProsima_user_DllExport uint32_t index() const + { + return m_index; + } + + /*! + * @brief This function returns a reference to member index + * @return Reference to member index + */ + eProsima_user_DllExport uint32_t& index() + { + return m_index; + } + + + /*! + * @brief This function copies the value in member sub_structs + * @param _sub_structs New value to be copied in member sub_structs + */ + eProsima_user_DllExport void sub_structs( + const std::array& _sub_structs) + { + m_sub_structs = _sub_structs; + } + + /*! + * @brief This function moves the value in member sub_structs + * @param _sub_structs New value to be moved in member sub_structs + */ + eProsima_user_DllExport void sub_structs( + std::array&& _sub_structs) + { + m_sub_structs = std::move(_sub_structs); + } + + /*! + * @brief This function returns a constant reference to member sub_structs + * @return Constant reference to member sub_structs + */ + eProsima_user_DllExport const std::array& sub_structs() const + { + return m_sub_structs; + } + + /*! + * @brief This function returns a reference to member sub_structs + * @return Reference to member sub_structs + */ + eProsima_user_DllExport std::array& sub_structs() + { + return m_sub_structs; + } + + + +private: + + uint32_t m_index{0}; + std::array m_sub_structs; + +}; + +#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp new file mode 100644 index 00000000000..aa07447f34f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp @@ -0,0 +1,53 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ + +#include "basic_array_struct.hpp" + +constexpr uint32_t basic_array_struct_max_cdr_typesize {69UL}; +constexpr uint32_t basic_array_struct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t TheOtherObjectInArray_max_cdr_typesize {9UL}; +constexpr uint32_t TheOtherObjectInArray_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObjectInArray& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const basic_array_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp new file mode 100644 index 00000000000..4d1ab4f1910 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp @@ -0,0 +1,210 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ + +#include "basic_array_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const TheOtherObjectInArray& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.some_num(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.positive(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObjectInArray& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.some_num() + << eprosima::fastcdr::MemberId(1) << data.positive() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + TheOtherObjectInArray& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.some_num(); + break; + + case 1: + dcdr >> data.positive(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObjectInArray& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const basic_array_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.index(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.sub_structs(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const basic_array_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.index() + << eprosima::fastcdr::MemberId(1) << data.sub_structs() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + basic_array_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.index(); + break; + + case 1: + dcdr >> data.sub_structs(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const basic_array_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx new file mode 100644 index 00000000000..b5359c6be69 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx @@ -0,0 +1,422 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "basic_array_structPubSubTypes.h" + +#include +#include + +#include "basic_array_structCdrAux.hpp" +#include "basic_array_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +TheOtherObjectInArrayPubSubType::TheOtherObjectInArrayPubSubType() +{ + setName("TheOtherObjectInArray"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(TheOtherObjectInArray::getMaxCdrSerializedSize()); +#else + TheOtherObjectInArray_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = TheOtherObjectInArray_max_key_cdr_typesize > 16 ? TheOtherObjectInArray_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +TheOtherObjectInArrayPubSubType::~TheOtherObjectInArrayPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool TheOtherObjectInArrayPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + TheOtherObjectInArray* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool TheOtherObjectInArrayPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + TheOtherObjectInArray* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* TheOtherObjectInArrayPubSubType::createData() +{ + return reinterpret_cast(new TheOtherObjectInArray()); +} + +void TheOtherObjectInArrayPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool TheOtherObjectInArrayPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + TheOtherObjectInArray* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + TheOtherObjectInArray_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || TheOtherObjectInArray_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void TheOtherObjectInArrayPubSubType::register_type_object_representation() +{ + register_TheOtherObjectInArray_type_identifier(type_identifiers_); +} + +basic_array_structPubSubType::basic_array_structPubSubType() +{ + setName("basic_array_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(basic_array_struct::getMaxCdrSerializedSize()); +#else + basic_array_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = basic_array_struct_max_key_cdr_typesize > 16 ? basic_array_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +basic_array_structPubSubType::~basic_array_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool basic_array_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + basic_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool basic_array_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + basic_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function basic_array_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* basic_array_structPubSubType::createData() +{ + return reinterpret_cast(new basic_array_struct()); +} + +void basic_array_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool basic_array_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + basic_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + basic_array_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || basic_array_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void basic_array_structPubSubType::register_type_object_representation() +{ + register_basic_array_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "basic_array_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h new file mode 100644 index 00000000000..4160c1bb961 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h @@ -0,0 +1,224 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "basic_array_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated basic_array_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type TheOtherObjectInArray defined by the user in the IDL file. + * @ingroup basic_array_struct + */ +class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef TheOtherObjectInArray type; + + eProsima_user_DllExport TheOtherObjectInArrayPubSubType(); + + eProsima_user_DllExport ~TheOtherObjectInArrayPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type basic_array_struct defined by the user in the IDL file. + * @ingroup basic_array_struct + */ +class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef basic_array_struct type; + + eProsima_user_DllExport basic_array_structPubSubType(); + + eProsima_user_DllExport ~basic_array_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..242ea8119a4 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx @@ -0,0 +1,251 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "basic_array_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "basic_array_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_TheOtherObjectInArray_type_identifier( + TypeIdentifierPair& type_ids_TheOtherObjectInArray) +{ + + ReturnCode_t return_code_TheOtherObjectInArray {eprosima::fastdds::dds::RETCODE_OK}; + return_code_TheOtherObjectInArray = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "TheOtherObjectInArray", type_ids_TheOtherObjectInArray); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_TheOtherObjectInArray) + { + StructTypeFlag struct_flags_TheOtherObjectInArray = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_TheOtherObjectInArray = "TheOtherObjectInArray"; + eprosima::fastcdr::optional type_ann_builtin_TheOtherObjectInArray; + eprosima::fastcdr::optional ann_custom_TheOtherObjectInArray; + CompleteTypeDetail detail_TheOtherObjectInArray = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_TheOtherObjectInArray, ann_custom_TheOtherObjectInArray, type_name_TheOtherObjectInArray.to_string()); + CompleteStructHeader header_TheOtherObjectInArray; + header_TheOtherObjectInArray = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_TheOtherObjectInArray); + CompleteStructMemberSeq member_seq_TheOtherObjectInArray; + { + TypeIdentifierPair type_ids_some_num; + ReturnCode_t return_code_some_num {eprosima::fastdds::dds::RETCODE_OK}; + return_code_some_num = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_some_num); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_some_num) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "some_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_some_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_some_num = 0x00000000; + bool common_some_num_ec {false}; + CommonStructMember common_some_num {TypeObjectUtils::build_common_struct_member(member_id_some_num, member_flags_some_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_some_num, common_some_num_ec))}; + if (!common_some_num_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure some_num member TypeIdentifier inconsistent."); + return; + } + MemberName name_some_num = "some_num"; + eprosima::fastcdr::optional member_ann_builtin_some_num; + ann_custom_TheOtherObjectInArray.reset(); + CompleteMemberDetail detail_some_num = TypeObjectUtils::build_complete_member_detail(name_some_num, member_ann_builtin_some_num, ann_custom_TheOtherObjectInArray); + CompleteStructMember member_some_num = TypeObjectUtils::build_complete_struct_member(common_some_num, detail_some_num); + TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObjectInArray, member_some_num); + } + { + TypeIdentifierPair type_ids_positive; + ReturnCode_t return_code_positive {eprosima::fastdds::dds::RETCODE_OK}; + return_code_positive = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_positive); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_positive) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "positive Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_positive = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_positive = 0x00000001; + bool common_positive_ec {false}; + CommonStructMember common_positive {TypeObjectUtils::build_common_struct_member(member_id_positive, member_flags_positive, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_positive, common_positive_ec))}; + if (!common_positive_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure positive member TypeIdentifier inconsistent."); + return; + } + MemberName name_positive = "positive"; + eprosima::fastcdr::optional member_ann_builtin_positive; + ann_custom_TheOtherObjectInArray.reset(); + CompleteMemberDetail detail_positive = TypeObjectUtils::build_complete_member_detail(name_positive, member_ann_builtin_positive, ann_custom_TheOtherObjectInArray); + CompleteStructMember member_positive = TypeObjectUtils::build_complete_struct_member(common_positive, detail_positive); + TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObjectInArray, member_positive); + } + CompleteStructType struct_type_TheOtherObjectInArray = TypeObjectUtils::build_complete_struct_type(struct_flags_TheOtherObjectInArray, header_TheOtherObjectInArray, member_seq_TheOtherObjectInArray); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_TheOtherObjectInArray, type_name_TheOtherObjectInArray.to_string(), type_ids_TheOtherObjectInArray)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "TheOtherObjectInArray already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_basic_array_struct_type_identifier( + TypeIdentifierPair& type_ids_basic_array_struct) +{ + + ReturnCode_t return_code_basic_array_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_basic_array_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "basic_array_struct", type_ids_basic_array_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_basic_array_struct) + { + StructTypeFlag struct_flags_basic_array_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_basic_array_struct = "basic_array_struct"; + eprosima::fastcdr::optional type_ann_builtin_basic_array_struct; + eprosima::fastcdr::optional ann_custom_basic_array_struct; + CompleteTypeDetail detail_basic_array_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_basic_array_struct, ann_custom_basic_array_struct, type_name_basic_array_struct.to_string()); + CompleteStructHeader header_basic_array_struct; + header_basic_array_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_basic_array_struct); + CompleteStructMemberSeq member_seq_basic_array_struct; + { + TypeIdentifierPair type_ids_index; + ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; + return_code_index = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_index); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_index = 0x00000000; + bool common_index_ec {false}; + CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; + if (!common_index_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); + return; + } + MemberName name_index = "index"; + eprosima::fastcdr::optional member_ann_builtin_index; + ann_custom_basic_array_struct.reset(); + CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_basic_array_struct); + CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); + TypeObjectUtils::add_complete_struct_member(member_seq_basic_array_struct, member_index); + } + { + TypeIdentifierPair type_ids_sub_structs; + ReturnCode_t return_code_sub_structs {eprosima::fastdds::dds::RETCODE_OK}; + return_code_sub_structs = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_TheOtherObjectInArray_5", type_ids_sub_structs); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_structs) + { + return_code_sub_structs = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "TheOtherObjectInArray", type_ids_sub_structs); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_structs) + { + ::register_TheOtherObjectInArray_type_identifier(type_ids_sub_structs); + } + bool element_identifier_anonymous_array_TheOtherObjectInArray_5_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_TheOtherObjectInArray_5 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_structs, element_identifier_anonymous_array_TheOtherObjectInArray_5_ec))}; + if (!element_identifier_anonymous_array_TheOtherObjectInArray_5_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_TheOtherObjectInArray_5 = EK_COMPLETE; + if (TK_NONE == type_ids_sub_structs.type_identifier2()._d()) + { + equiv_kind_anonymous_array_TheOtherObjectInArray_5 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_TheOtherObjectInArray_5 = 0; + PlainCollectionHeader header_anonymous_array_TheOtherObjectInArray_5 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_TheOtherObjectInArray_5, element_flags_anonymous_array_TheOtherObjectInArray_5); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_TheOtherObjectInArray_5, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_TheOtherObjectInArray_5)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_TheOtherObjectInArray_5", type_ids_sub_structs)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_TheOtherObjectInArray_5 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_sub_structs = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_sub_structs = 0x00000001; + bool common_sub_structs_ec {false}; + CommonStructMember common_sub_structs {TypeObjectUtils::build_common_struct_member(member_id_sub_structs, member_flags_sub_structs, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_structs, common_sub_structs_ec))}; + if (!common_sub_structs_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub_structs member TypeIdentifier inconsistent."); + return; + } + MemberName name_sub_structs = "sub_structs"; + eprosima::fastcdr::optional member_ann_builtin_sub_structs; + ann_custom_basic_array_struct.reset(); + CompleteMemberDetail detail_sub_structs = TypeObjectUtils::build_complete_member_detail(name_sub_structs, member_ann_builtin_sub_structs, ann_custom_basic_array_struct); + CompleteStructMember member_sub_structs = TypeObjectUtils::build_complete_struct_member(common_sub_structs, detail_sub_structs); + TypeObjectUtils::add_complete_struct_member(member_seq_basic_array_struct, member_sub_structs); + } + CompleteStructType struct_type_basic_array_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_basic_array_struct, header_basic_array_struct, member_seq_basic_array_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_basic_array_struct, type_name_basic_array_struct.to_string(), type_ids_basic_array_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "basic_array_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..c6be16a7745 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_array_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register TheOtherObjectInArray related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_TheOtherObjectInArray_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register basic_array_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_basic_array_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp new file mode 100644 index 00000000000..03642cf33f2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp @@ -0,0 +1,311 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(BASIC_STRUCT_SOURCE) +#define BASIC_STRUCT_DllAPI __declspec( dllexport ) +#else +#define BASIC_STRUCT_DllAPI __declspec( dllimport ) +#endif // BASIC_STRUCT_SOURCE +#else +#define BASIC_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define BASIC_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure TheOtherObject defined by the user in the IDL file. + * @ingroup basic_struct + */ +class TheOtherObject +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport TheOtherObject() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~TheOtherObject() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object TheOtherObject that will be copied. + */ + eProsima_user_DllExport TheOtherObject( + const TheOtherObject& x) + { + m_some_num = x.m_some_num; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object TheOtherObject that will be copied. + */ + eProsima_user_DllExport TheOtherObject( + TheOtherObject&& x) noexcept + { + m_some_num = x.m_some_num; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object TheOtherObject that will be copied. + */ + eProsima_user_DllExport TheOtherObject& operator =( + const TheOtherObject& x) + { + + m_some_num = x.m_some_num; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object TheOtherObject that will be copied. + */ + eProsima_user_DllExport TheOtherObject& operator =( + TheOtherObject&& x) noexcept + { + + m_some_num = x.m_some_num; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x TheOtherObject object to compare. + */ + eProsima_user_DllExport bool operator ==( + const TheOtherObject& x) const + { + return (m_some_num == x.m_some_num); + } + + /*! + * @brief Comparison operator. + * @param x TheOtherObject object to compare. + */ + eProsima_user_DllExport bool operator !=( + const TheOtherObject& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member some_num + * @param _some_num New value for member some_num + */ + eProsima_user_DllExport void some_num( + int32_t _some_num) + { + m_some_num = _some_num; + } + + /*! + * @brief This function returns the value of member some_num + * @return Value of member some_num + */ + eProsima_user_DllExport int32_t some_num() const + { + return m_some_num; + } + + /*! + * @brief This function returns a reference to member some_num + * @return Reference to member some_num + */ + eProsima_user_DllExport int32_t& some_num() + { + return m_some_num; + } + + + +private: + + int32_t m_some_num{0}; + +}; +/*! + * @brief This class represents the structure basic_struct defined by the user in the IDL file. + * @ingroup basic_struct + */ +class basic_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport basic_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~basic_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object basic_struct that will be copied. + */ + eProsima_user_DllExport basic_struct( + const basic_struct& x) + { + m_sub_struct = x.m_sub_struct; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object basic_struct that will be copied. + */ + eProsima_user_DllExport basic_struct( + basic_struct&& x) noexcept + { + m_sub_struct = std::move(x.m_sub_struct); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object basic_struct that will be copied. + */ + eProsima_user_DllExport basic_struct& operator =( + const basic_struct& x) + { + + m_sub_struct = x.m_sub_struct; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object basic_struct that will be copied. + */ + eProsima_user_DllExport basic_struct& operator =( + basic_struct&& x) noexcept + { + + m_sub_struct = std::move(x.m_sub_struct); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x basic_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const basic_struct& x) const + { + return (m_sub_struct == x.m_sub_struct); + } + + /*! + * @brief Comparison operator. + * @param x basic_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const basic_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member sub_struct + * @param _sub_struct New value to be copied in member sub_struct + */ + eProsima_user_DllExport void sub_struct( + const TheOtherObject& _sub_struct) + { + m_sub_struct = _sub_struct; + } + + /*! + * @brief This function moves the value in member sub_struct + * @param _sub_struct New value to be moved in member sub_struct + */ + eProsima_user_DllExport void sub_struct( + TheOtherObject&& _sub_struct) + { + m_sub_struct = std::move(_sub_struct); + } + + /*! + * @brief This function returns a constant reference to member sub_struct + * @return Constant reference to member sub_struct + */ + eProsima_user_DllExport const TheOtherObject& sub_struct() const + { + return m_sub_struct; + } + + /*! + * @brief This function returns a reference to member sub_struct + * @return Reference to member sub_struct + */ + eProsima_user_DllExport TheOtherObject& sub_struct() + { + return m_sub_struct; + } + + + +private: + + TheOtherObject m_sub_struct; + +}; + +#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp new file mode 100644 index 00000000000..1b9a2ea8765 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp @@ -0,0 +1,53 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ + +#include "basic_struct.hpp" + +constexpr uint32_t basic_struct_max_cdr_typesize {12UL}; +constexpr uint32_t basic_struct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t TheOtherObject_max_cdr_typesize {8UL}; +constexpr uint32_t TheOtherObject_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObject& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const basic_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp new file mode 100644 index 00000000000..d936fdf2123 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp @@ -0,0 +1,194 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ + +#include "basic_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const TheOtherObject& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.some_num(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObject& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.some_num() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + TheOtherObject& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.some_num(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const TheOtherObject& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const basic_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.sub_struct(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const basic_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.sub_struct() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + basic_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.sub_struct(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const basic_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx new file mode 100644 index 00000000000..32bca4addb2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx @@ -0,0 +1,422 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "basic_structPubSubTypes.h" + +#include +#include + +#include "basic_structCdrAux.hpp" +#include "basic_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +TheOtherObjectPubSubType::TheOtherObjectPubSubType() +{ + setName("TheOtherObject"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(TheOtherObject::getMaxCdrSerializedSize()); +#else + TheOtherObject_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = TheOtherObject_max_key_cdr_typesize > 16 ? TheOtherObject_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +TheOtherObjectPubSubType::~TheOtherObjectPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool TheOtherObjectPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + TheOtherObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool TheOtherObjectPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + TheOtherObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function TheOtherObjectPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* TheOtherObjectPubSubType::createData() +{ + return reinterpret_cast(new TheOtherObject()); +} + +void TheOtherObjectPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool TheOtherObjectPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + TheOtherObject* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + TheOtherObject_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || TheOtherObject_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void TheOtherObjectPubSubType::register_type_object_representation() +{ + register_TheOtherObject_type_identifier(type_identifiers_); +} + +basic_structPubSubType::basic_structPubSubType() +{ + setName("basic_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(basic_struct::getMaxCdrSerializedSize()); +#else + basic_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = basic_struct_max_key_cdr_typesize > 16 ? basic_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +basic_structPubSubType::~basic_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool basic_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + basic_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool basic_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + basic_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function basic_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* basic_structPubSubType::createData() +{ + return reinterpret_cast(new basic_struct()); +} + +void basic_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool basic_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + basic_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + basic_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || basic_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void basic_structPubSubType::register_type_object_representation() +{ + register_basic_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "basic_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h new file mode 100644 index 00000000000..b51cf7149f2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h @@ -0,0 +1,224 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "basic_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated basic_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type TheOtherObject defined by the user in the IDL file. + * @ingroup basic_struct + */ +class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef TheOtherObject type; + + eProsima_user_DllExport TheOtherObjectPubSubType(); + + eProsima_user_DllExport ~TheOtherObjectPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type basic_struct defined by the user in the IDL file. + * @ingroup basic_struct + */ +class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef basic_struct type; + + eProsima_user_DllExport basic_structPubSubType(); + + eProsima_user_DllExport ~basic_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..b57ea0db1c6 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx @@ -0,0 +1,157 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "basic_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "basic_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_TheOtherObject_type_identifier( + TypeIdentifierPair& type_ids_TheOtherObject) +{ + + ReturnCode_t return_code_TheOtherObject {eprosima::fastdds::dds::RETCODE_OK}; + return_code_TheOtherObject = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "TheOtherObject", type_ids_TheOtherObject); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_TheOtherObject) + { + StructTypeFlag struct_flags_TheOtherObject = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_TheOtherObject = "TheOtherObject"; + eprosima::fastcdr::optional type_ann_builtin_TheOtherObject; + eprosima::fastcdr::optional ann_custom_TheOtherObject; + CompleteTypeDetail detail_TheOtherObject = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_TheOtherObject, ann_custom_TheOtherObject, type_name_TheOtherObject.to_string()); + CompleteStructHeader header_TheOtherObject; + header_TheOtherObject = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_TheOtherObject); + CompleteStructMemberSeq member_seq_TheOtherObject; + { + TypeIdentifierPair type_ids_some_num; + ReturnCode_t return_code_some_num {eprosima::fastdds::dds::RETCODE_OK}; + return_code_some_num = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_some_num); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_some_num) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "some_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_some_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_some_num = 0x00000000; + bool common_some_num_ec {false}; + CommonStructMember common_some_num {TypeObjectUtils::build_common_struct_member(member_id_some_num, member_flags_some_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_some_num, common_some_num_ec))}; + if (!common_some_num_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure some_num member TypeIdentifier inconsistent."); + return; + } + MemberName name_some_num = "some_num"; + eprosima::fastcdr::optional member_ann_builtin_some_num; + ann_custom_TheOtherObject.reset(); + CompleteMemberDetail detail_some_num = TypeObjectUtils::build_complete_member_detail(name_some_num, member_ann_builtin_some_num, ann_custom_TheOtherObject); + CompleteStructMember member_some_num = TypeObjectUtils::build_complete_struct_member(common_some_num, detail_some_num); + TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObject, member_some_num); + } + CompleteStructType struct_type_TheOtherObject = TypeObjectUtils::build_complete_struct_type(struct_flags_TheOtherObject, header_TheOtherObject, member_seq_TheOtherObject); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_TheOtherObject, type_name_TheOtherObject.to_string(), type_ids_TheOtherObject)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "TheOtherObject already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_basic_struct_type_identifier( + TypeIdentifierPair& type_ids_basic_struct) +{ + + ReturnCode_t return_code_basic_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_basic_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "basic_struct", type_ids_basic_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_basic_struct) + { + StructTypeFlag struct_flags_basic_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_basic_struct = "basic_struct"; + eprosima::fastcdr::optional type_ann_builtin_basic_struct; + eprosima::fastcdr::optional ann_custom_basic_struct; + CompleteTypeDetail detail_basic_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_basic_struct, ann_custom_basic_struct, type_name_basic_struct.to_string()); + CompleteStructHeader header_basic_struct; + header_basic_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_basic_struct); + CompleteStructMemberSeq member_seq_basic_struct; + { + TypeIdentifierPair type_ids_sub_struct; + ReturnCode_t return_code_sub_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_sub_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "TheOtherObject", type_ids_sub_struct); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_struct) + { + ::register_TheOtherObject_type_identifier(type_ids_sub_struct); + } + StructMemberFlag member_flags_sub_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_sub_struct = 0x00000000; + bool common_sub_struct_ec {false}; + CommonStructMember common_sub_struct {TypeObjectUtils::build_common_struct_member(member_id_sub_struct, member_flags_sub_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_struct, common_sub_struct_ec))}; + if (!common_sub_struct_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub_struct member TypeIdentifier inconsistent."); + return; + } + MemberName name_sub_struct = "sub_struct"; + eprosima::fastcdr::optional member_ann_builtin_sub_struct; + ann_custom_basic_struct.reset(); + CompleteMemberDetail detail_sub_struct = TypeObjectUtils::build_complete_member_detail(name_sub_struct, member_ann_builtin_sub_struct, ann_custom_basic_struct); + CompleteStructMember member_sub_struct = TypeObjectUtils::build_complete_struct_member(common_sub_struct, detail_sub_struct); + TypeObjectUtils::add_complete_struct_member(member_seq_basic_struct, member_sub_struct); + } + CompleteStructType struct_type_basic_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_basic_struct, header_basic_struct, member_seq_basic_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_basic_struct, type_name_basic_struct.to_string(), type_ids_basic_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "basic_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..63cc1a64d7c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file basic_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register TheOtherObject related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_TheOtherObject_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register basic_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_basic_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp new file mode 100644 index 00000000000..f1cb9210ba2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp @@ -0,0 +1,190 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequence.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ +#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ + +#include +#include +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(CHAR_SEQUENCE_SOURCE) +#define CHAR_SEQUENCE_DllAPI __declspec( dllexport ) +#else +#define CHAR_SEQUENCE_DllAPI __declspec( dllimport ) +#endif // CHAR_SEQUENCE_SOURCE +#else +#define CHAR_SEQUENCE_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define CHAR_SEQUENCE_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure char_sequence defined by the user in the IDL file. + * @ingroup char_sequence + */ +class char_sequence +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport char_sequence() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~char_sequence() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object char_sequence that will be copied. + */ + eProsima_user_DllExport char_sequence( + const char_sequence& x) + { + m_chars = x.m_chars; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object char_sequence that will be copied. + */ + eProsima_user_DllExport char_sequence( + char_sequence&& x) noexcept + { + m_chars = std::move(x.m_chars); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object char_sequence that will be copied. + */ + eProsima_user_DllExport char_sequence& operator =( + const char_sequence& x) + { + + m_chars = x.m_chars; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object char_sequence that will be copied. + */ + eProsima_user_DllExport char_sequence& operator =( + char_sequence&& x) noexcept + { + + m_chars = std::move(x.m_chars); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x char_sequence object to compare. + */ + eProsima_user_DllExport bool operator ==( + const char_sequence& x) const + { + return (m_chars == x.m_chars); + } + + /*! + * @brief Comparison operator. + * @param x char_sequence object to compare. + */ + eProsima_user_DllExport bool operator !=( + const char_sequence& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member chars + * @param _chars New value to be copied in member chars + */ + eProsima_user_DllExport void chars( + const std::vector& _chars) + { + m_chars = _chars; + } + + /*! + * @brief This function moves the value in member chars + * @param _chars New value to be moved in member chars + */ + eProsima_user_DllExport void chars( + std::vector&& _chars) + { + m_chars = std::move(_chars); + } + + /*! + * @brief This function returns a constant reference to member chars + * @return Constant reference to member chars + */ + eProsima_user_DllExport const std::vector& chars() const + { + return m_chars; + } + + /*! + * @brief This function returns a reference to member chars + * @return Reference to member chars + */ + eProsima_user_DllExport std::vector& chars() + { + return m_chars; + } + + + +private: + + std::vector m_chars; + +}; + +#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp new file mode 100644 index 00000000000..11d7c4bd848 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequenceCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ +#define _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ + +#include "char_sequence.hpp" + +constexpr uint32_t char_sequence_max_cdr_typesize {8UL}; +constexpr uint32_t char_sequence_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const char_sequence& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp new file mode 100644 index 00000000000..756dc0bd977 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequenceCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ +#define _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ + +#include "char_sequenceCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const char_sequence& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.chars(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const char_sequence& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.chars() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + char_sequence& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.chars(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const char_sequence& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx new file mode 100644 index 00000000000..297c28c835f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequencePubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "char_sequencePubSubTypes.h" + +#include +#include + +#include "char_sequenceCdrAux.hpp" +#include "char_sequenceTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +char_sequencePubSubType::char_sequencePubSubType() +{ + setName("char_sequence"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(char_sequence::getMaxCdrSerializedSize()); +#else + char_sequence_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = char_sequence_max_key_cdr_typesize > 16 ? char_sequence_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +char_sequencePubSubType::~char_sequencePubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool char_sequencePubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + char_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool char_sequencePubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + char_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function char_sequencePubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* char_sequencePubSubType::createData() +{ + return reinterpret_cast(new char_sequence()); +} + +void char_sequencePubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool char_sequencePubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + char_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + char_sequence_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || char_sequence_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void char_sequencePubSubType::register_type_object_representation() +{ + register_char_sequence_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "char_sequenceCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h new file mode 100644 index 00000000000..4441dba08d3 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequencePubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "char_sequence.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated char_sequence is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type char_sequence defined by the user in the IDL file. + * @ingroup char_sequence + */ +class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef char_sequence type; + + eProsima_user_DllExport char_sequencePubSubType(); + + eProsima_user_DllExport ~char_sequencePubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx new file mode 100644 index 00000000000..24ddf288868 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx @@ -0,0 +1,132 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequenceTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "char_sequenceTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "char_sequence.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_char_sequence_type_identifier( + TypeIdentifierPair& type_ids_char_sequence) +{ + + ReturnCode_t return_code_char_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_char_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "char_sequence", type_ids_char_sequence); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_char_sequence) + { + StructTypeFlag struct_flags_char_sequence = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_char_sequence = "char_sequence"; + eprosima::fastcdr::optional type_ann_builtin_char_sequence; + eprosima::fastcdr::optional ann_custom_char_sequence; + CompleteTypeDetail detail_char_sequence = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_char_sequence, ann_custom_char_sequence, type_name_char_sequence.to_string()); + CompleteStructHeader header_char_sequence; + header_char_sequence = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_char_sequence); + CompleteStructMemberSeq member_seq_char_sequence; + { + TypeIdentifierPair type_ids_chars; + ReturnCode_t return_code_chars {eprosima::fastdds::dds::RETCODE_OK}; + return_code_chars = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_char_unbounded", type_ids_chars); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_chars) + { + return_code_chars = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_char", type_ids_chars); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_chars) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_sequence_char_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_char_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_chars, element_identifier_anonymous_sequence_char_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_char_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_char_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_chars.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_char_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_char_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_char_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_char_unbounded, element_flags_anonymous_sequence_char_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_char_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_char_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_char_unbounded", type_ids_chars)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_char_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_chars = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_chars = 0x00000000; + bool common_chars_ec {false}; + CommonStructMember common_chars {TypeObjectUtils::build_common_struct_member(member_id_chars, member_flags_chars, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_chars, common_chars_ec))}; + if (!common_chars_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure chars member TypeIdentifier inconsistent."); + return; + } + MemberName name_chars = "chars"; + eprosima::fastcdr::optional member_ann_builtin_chars; + ann_custom_char_sequence.reset(); + CompleteMemberDetail detail_chars = TypeObjectUtils::build_complete_member_detail(name_chars, member_ann_builtin_chars, ann_custom_char_sequence); + CompleteStructMember member_chars = TypeObjectUtils::build_complete_struct_member(common_chars, detail_chars); + TypeObjectUtils::add_complete_struct_member(member_seq_char_sequence, member_chars); + } + CompleteStructType struct_type_char_sequence = TypeObjectUtils::build_complete_struct_type(struct_flags_char_sequence, header_char_sequence, member_seq_char_sequence); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_char_sequence, type_name_char_sequence.to_string(), type_ids_char_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "char_sequence already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp new file mode 100644 index 00000000000..7167bf5a0d0 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file char_sequenceTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register char_sequence related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_char_sequence_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp new file mode 100644 index 00000000000..044a0055e98 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp @@ -0,0 +1,760 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arrays.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ +#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ + +#include +#include +#include +#include +#include + +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(COMPLEX_NESTED_ARRAYS_SOURCE) +#define COMPLEX_NESTED_ARRAYS_DllAPI __declspec( dllexport ) +#else +#define COMPLEX_NESTED_ARRAYS_DllAPI __declspec( dllimport ) +#endif // COMPLEX_NESTED_ARRAYS_SOURCE +#else +#define COMPLEX_NESTED_ARRAYS_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define COMPLEX_NESTED_ARRAYS_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure ThirdLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class ThirdLevelElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ThirdLevelElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ThirdLevelElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ThirdLevelElement that will be copied. + */ + eProsima_user_DllExport ThirdLevelElement( + const ThirdLevelElement& x) + { + m_x = x.m_x; + + m_y = x.m_y; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ThirdLevelElement that will be copied. + */ + eProsima_user_DllExport ThirdLevelElement( + ThirdLevelElement&& x) noexcept + { + m_x = x.m_x; + m_y = x.m_y; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ThirdLevelElement that will be copied. + */ + eProsima_user_DllExport ThirdLevelElement& operator =( + const ThirdLevelElement& x) + { + + m_x = x.m_x; + + m_y = x.m_y; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ThirdLevelElement that will be copied. + */ + eProsima_user_DllExport ThirdLevelElement& operator =( + ThirdLevelElement&& x) noexcept + { + + m_x = x.m_x; + m_y = x.m_y; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ThirdLevelElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ThirdLevelElement& x) const + { + return (m_x == x.m_x && + m_y == x.m_y); + } + + /*! + * @brief Comparison operator. + * @param x ThirdLevelElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ThirdLevelElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member x + * @param _x New value for member x + */ + eProsima_user_DllExport void x( + double _x) + { + m_x = _x; + } + + /*! + * @brief This function returns the value of member x + * @return Value of member x + */ + eProsima_user_DllExport double x() const + { + return m_x; + } + + /*! + * @brief This function returns a reference to member x + * @return Reference to member x + */ + eProsima_user_DllExport double& x() + { + return m_x; + } + + + /*! + * @brief This function sets a value in member y + * @param _y New value for member y + */ + eProsima_user_DllExport void y( + double _y) + { + m_y = _y; + } + + /*! + * @brief This function returns the value of member y + * @return Value of member y + */ + eProsima_user_DllExport double y() const + { + return m_y; + } + + /*! + * @brief This function returns a reference to member y + * @return Reference to member y + */ + eProsima_user_DllExport double& y() + { + return m_y; + } + + + +private: + + double m_x{0.0}; + double m_y{0.0}; + +}; +/*! + * @brief This class represents the structure SecondLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class SecondLevelElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport SecondLevelElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~SecondLevelElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object SecondLevelElement that will be copied. + */ + eProsima_user_DllExport SecondLevelElement( + const SecondLevelElement& x) + { + m_an_element_alone = x.m_an_element_alone; + + m_a_limited_other_value = x.m_a_limited_other_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object SecondLevelElement that will be copied. + */ + eProsima_user_DllExport SecondLevelElement( + SecondLevelElement&& x) noexcept + { + m_an_element_alone = std::move(x.m_an_element_alone); + m_a_limited_other_value = std::move(x.m_a_limited_other_value); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object SecondLevelElement that will be copied. + */ + eProsima_user_DllExport SecondLevelElement& operator =( + const SecondLevelElement& x) + { + + m_an_element_alone = x.m_an_element_alone; + + m_a_limited_other_value = x.m_a_limited_other_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object SecondLevelElement that will be copied. + */ + eProsima_user_DllExport SecondLevelElement& operator =( + SecondLevelElement&& x) noexcept + { + + m_an_element_alone = std::move(x.m_an_element_alone); + m_a_limited_other_value = std::move(x.m_a_limited_other_value); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x SecondLevelElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const SecondLevelElement& x) const + { + return (m_an_element_alone == x.m_an_element_alone && + m_a_limited_other_value == x.m_a_limited_other_value); + } + + /*! + * @brief Comparison operator. + * @param x SecondLevelElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const SecondLevelElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member an_element_alone + * @param _an_element_alone New value to be copied in member an_element_alone + */ + eProsima_user_DllExport void an_element_alone( + const ThirdLevelElement& _an_element_alone) + { + m_an_element_alone = _an_element_alone; + } + + /*! + * @brief This function moves the value in member an_element_alone + * @param _an_element_alone New value to be moved in member an_element_alone + */ + eProsima_user_DllExport void an_element_alone( + ThirdLevelElement&& _an_element_alone) + { + m_an_element_alone = std::move(_an_element_alone); + } + + /*! + * @brief This function returns a constant reference to member an_element_alone + * @return Constant reference to member an_element_alone + */ + eProsima_user_DllExport const ThirdLevelElement& an_element_alone() const + { + return m_an_element_alone; + } + + /*! + * @brief This function returns a reference to member an_element_alone + * @return Reference to member an_element_alone + */ + eProsima_user_DllExport ThirdLevelElement& an_element_alone() + { + return m_an_element_alone; + } + + + /*! + * @brief This function copies the value in member a_limited_other_value + * @param _a_limited_other_value New value to be copied in member a_limited_other_value + */ + eProsima_user_DllExport void a_limited_other_value( + const std::vector& _a_limited_other_value) + { + m_a_limited_other_value = _a_limited_other_value; + } + + /*! + * @brief This function moves the value in member a_limited_other_value + * @param _a_limited_other_value New value to be moved in member a_limited_other_value + */ + eProsima_user_DllExport void a_limited_other_value( + std::vector&& _a_limited_other_value) + { + m_a_limited_other_value = std::move(_a_limited_other_value); + } + + /*! + * @brief This function returns a constant reference to member a_limited_other_value + * @return Constant reference to member a_limited_other_value + */ + eProsima_user_DllExport const std::vector& a_limited_other_value() const + { + return m_a_limited_other_value; + } + + /*! + * @brief This function returns a reference to member a_limited_other_value + * @return Reference to member a_limited_other_value + */ + eProsima_user_DllExport std::vector& a_limited_other_value() + { + return m_a_limited_other_value; + } + + + +private: + + ThirdLevelElement m_an_element_alone; + std::vector m_a_limited_other_value; + +}; +/*! + * @brief This class represents the structure FirstLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class FirstLevelElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FirstLevelElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FirstLevelElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FirstLevelElement that will be copied. + */ + eProsima_user_DllExport FirstLevelElement( + const FirstLevelElement& x) + { + m_useless_name = x.m_useless_name; + + m_sub = x.m_sub; + + m_an_element_alone = x.m_an_element_alone; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FirstLevelElement that will be copied. + */ + eProsima_user_DllExport FirstLevelElement( + FirstLevelElement&& x) noexcept + { + m_useless_name = std::move(x.m_useless_name); + m_sub = std::move(x.m_sub); + m_an_element_alone = std::move(x.m_an_element_alone); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FirstLevelElement that will be copied. + */ + eProsima_user_DllExport FirstLevelElement& operator =( + const FirstLevelElement& x) + { + + m_useless_name = x.m_useless_name; + + m_sub = x.m_sub; + + m_an_element_alone = x.m_an_element_alone; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FirstLevelElement that will be copied. + */ + eProsima_user_DllExport FirstLevelElement& operator =( + FirstLevelElement&& x) noexcept + { + + m_useless_name = std::move(x.m_useless_name); + m_sub = std::move(x.m_sub); + m_an_element_alone = std::move(x.m_an_element_alone); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FirstLevelElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FirstLevelElement& x) const + { + return (m_useless_name == x.m_useless_name && + m_sub == x.m_sub && + m_an_element_alone == x.m_an_element_alone); + } + + /*! + * @brief Comparison operator. + * @param x FirstLevelElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FirstLevelElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member useless_name + * @param _useless_name New value to be copied in member useless_name + */ + eProsima_user_DllExport void useless_name( + const std::string& _useless_name) + { + m_useless_name = _useless_name; + } + + /*! + * @brief This function moves the value in member useless_name + * @param _useless_name New value to be moved in member useless_name + */ + eProsima_user_DllExport void useless_name( + std::string&& _useless_name) + { + m_useless_name = std::move(_useless_name); + } + + /*! + * @brief This function returns a constant reference to member useless_name + * @return Constant reference to member useless_name + */ + eProsima_user_DllExport const std::string& useless_name() const + { + return m_useless_name; + } + + /*! + * @brief This function returns a reference to member useless_name + * @return Reference to member useless_name + */ + eProsima_user_DllExport std::string& useless_name() + { + return m_useless_name; + } + + + /*! + * @brief This function copies the value in member sub + * @param _sub New value to be copied in member sub + */ + eProsima_user_DllExport void sub( + const std::vector& _sub) + { + m_sub = _sub; + } + + /*! + * @brief This function moves the value in member sub + * @param _sub New value to be moved in member sub + */ + eProsima_user_DllExport void sub( + std::vector&& _sub) + { + m_sub = std::move(_sub); + } + + /*! + * @brief This function returns a constant reference to member sub + * @return Constant reference to member sub + */ + eProsima_user_DllExport const std::vector& sub() const + { + return m_sub; + } + + /*! + * @brief This function returns a reference to member sub + * @return Reference to member sub + */ + eProsima_user_DllExport std::vector& sub() + { + return m_sub; + } + + + /*! + * @brief This function copies the value in member an_element_alone + * @param _an_element_alone New value to be copied in member an_element_alone + */ + eProsima_user_DllExport void an_element_alone( + const ThirdLevelElement& _an_element_alone) + { + m_an_element_alone = _an_element_alone; + } + + /*! + * @brief This function moves the value in member an_element_alone + * @param _an_element_alone New value to be moved in member an_element_alone + */ + eProsima_user_DllExport void an_element_alone( + ThirdLevelElement&& _an_element_alone) + { + m_an_element_alone = std::move(_an_element_alone); + } + + /*! + * @brief This function returns a constant reference to member an_element_alone + * @return Constant reference to member an_element_alone + */ + eProsima_user_DllExport const ThirdLevelElement& an_element_alone() const + { + return m_an_element_alone; + } + + /*! + * @brief This function returns a reference to member an_element_alone + * @return Reference to member an_element_alone + */ + eProsima_user_DllExport ThirdLevelElement& an_element_alone() + { + return m_an_element_alone; + } + + + +private: + + std::string m_useless_name; + std::vector m_sub; + ThirdLevelElement m_an_element_alone; + +}; +/*! + * @brief This class represents the structure complex_nested_arrays defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class complex_nested_arrays +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport complex_nested_arrays() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~complex_nested_arrays() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object complex_nested_arrays that will be copied. + */ + eProsima_user_DllExport complex_nested_arrays( + const complex_nested_arrays& x) + { + m_array_of_elements = x.m_array_of_elements; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object complex_nested_arrays that will be copied. + */ + eProsima_user_DllExport complex_nested_arrays( + complex_nested_arrays&& x) noexcept + { + m_array_of_elements = std::move(x.m_array_of_elements); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object complex_nested_arrays that will be copied. + */ + eProsima_user_DllExport complex_nested_arrays& operator =( + const complex_nested_arrays& x) + { + + m_array_of_elements = x.m_array_of_elements; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object complex_nested_arrays that will be copied. + */ + eProsima_user_DllExport complex_nested_arrays& operator =( + complex_nested_arrays&& x) noexcept + { + + m_array_of_elements = std::move(x.m_array_of_elements); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x complex_nested_arrays object to compare. + */ + eProsima_user_DllExport bool operator ==( + const complex_nested_arrays& x) const + { + return (m_array_of_elements == x.m_array_of_elements); + } + + /*! + * @brief Comparison operator. + * @param x complex_nested_arrays object to compare. + */ + eProsima_user_DllExport bool operator !=( + const complex_nested_arrays& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member array_of_elements + * @param _array_of_elements New value to be copied in member array_of_elements + */ + eProsima_user_DllExport void array_of_elements( + const std::array& _array_of_elements) + { + m_array_of_elements = _array_of_elements; + } + + /*! + * @brief This function moves the value in member array_of_elements + * @param _array_of_elements New value to be moved in member array_of_elements + */ + eProsima_user_DllExport void array_of_elements( + std::array&& _array_of_elements) + { + m_array_of_elements = std::move(_array_of_elements); + } + + /*! + * @brief This function returns a constant reference to member array_of_elements + * @return Constant reference to member array_of_elements + */ + eProsima_user_DllExport const std::array& array_of_elements() const + { + return m_array_of_elements; + } + + /*! + * @brief This function returns a reference to member array_of_elements + * @return Reference to member array_of_elements + */ + eProsima_user_DllExport std::array& array_of_elements() + { + return m_array_of_elements; + } + + + +private: + + std::array m_array_of_elements; + +}; + +#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp new file mode 100644 index 00000000000..ee7758a8ef4 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp @@ -0,0 +1,67 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ + +#include "complex_nested_arrays.hpp" + +constexpr uint32_t FirstLevelElement_max_cdr_typesize {296UL}; +constexpr uint32_t FirstLevelElement_max_key_cdr_typesize {0UL}; + +constexpr uint32_t ThirdLevelElement_max_cdr_typesize {24UL}; +constexpr uint32_t ThirdLevelElement_max_key_cdr_typesize {0UL}; + +constexpr uint32_t SecondLevelElement_max_cdr_typesize {56UL}; +constexpr uint32_t SecondLevelElement_max_key_cdr_typesize {0UL}; + +constexpr uint32_t complex_nested_arrays_max_cdr_typesize {896UL}; +constexpr uint32_t complex_nested_arrays_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ThirdLevelElement& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SecondLevelElement& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FirstLevelElement& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const complex_nested_arrays& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp new file mode 100644 index 00000000000..43e2c0e86ee --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp @@ -0,0 +1,378 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ + +#include "complex_nested_arraysCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ThirdLevelElement& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.x(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.y(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ThirdLevelElement& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.x() + << eprosima::fastcdr::MemberId(1) << data.y() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + ThirdLevelElement& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.x(); + break; + + case 1: + dcdr >> data.y(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ThirdLevelElement& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const SecondLevelElement& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.an_element_alone(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.a_limited_other_value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const SecondLevelElement& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.an_element_alone() + << eprosima::fastcdr::MemberId(1) << data.a_limited_other_value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + SecondLevelElement& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.an_element_alone(); + break; + + case 1: + dcdr >> data.a_limited_other_value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SecondLevelElement& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FirstLevelElement& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.useless_name(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.sub(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.an_element_alone(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FirstLevelElement& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.useless_name() + << eprosima::fastcdr::MemberId(1) << data.sub() + << eprosima::fastcdr::MemberId(2) << data.an_element_alone() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FirstLevelElement& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.useless_name(); + break; + + case 1: + dcdr >> data.sub(); + break; + + case 2: + dcdr >> data.an_element_alone(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FirstLevelElement& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const complex_nested_arrays& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.array_of_elements(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const complex_nested_arrays& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.array_of_elements() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + complex_nested_arrays& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.array_of_elements(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const complex_nested_arrays& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx new file mode 100644 index 00000000000..3f8ef309915 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx @@ -0,0 +1,808 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "complex_nested_arraysPubSubTypes.h" + +#include +#include + +#include "complex_nested_arraysCdrAux.hpp" +#include "complex_nested_arraysTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +ThirdLevelElementPubSubType::ThirdLevelElementPubSubType() +{ + setName("ThirdLevelElement"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(ThirdLevelElement::getMaxCdrSerializedSize()); +#else + ThirdLevelElement_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = ThirdLevelElement_max_key_cdr_typesize > 16 ? ThirdLevelElement_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +ThirdLevelElementPubSubType::~ThirdLevelElementPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool ThirdLevelElementPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + ThirdLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool ThirdLevelElementPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + ThirdLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function ThirdLevelElementPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* ThirdLevelElementPubSubType::createData() +{ + return reinterpret_cast(new ThirdLevelElement()); +} + +void ThirdLevelElementPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool ThirdLevelElementPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + ThirdLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + ThirdLevelElement_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || ThirdLevelElement_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void ThirdLevelElementPubSubType::register_type_object_representation() +{ + register_ThirdLevelElement_type_identifier(type_identifiers_); +} + +SecondLevelElementPubSubType::SecondLevelElementPubSubType() +{ + setName("SecondLevelElement"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(SecondLevelElement::getMaxCdrSerializedSize()); +#else + SecondLevelElement_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = SecondLevelElement_max_key_cdr_typesize > 16 ? SecondLevelElement_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +SecondLevelElementPubSubType::~SecondLevelElementPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool SecondLevelElementPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + SecondLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool SecondLevelElementPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + SecondLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function SecondLevelElementPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* SecondLevelElementPubSubType::createData() +{ + return reinterpret_cast(new SecondLevelElement()); +} + +void SecondLevelElementPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool SecondLevelElementPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + SecondLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + SecondLevelElement_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || SecondLevelElement_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void SecondLevelElementPubSubType::register_type_object_representation() +{ + register_SecondLevelElement_type_identifier(type_identifiers_); +} + +FirstLevelElementPubSubType::FirstLevelElementPubSubType() +{ + setName("FirstLevelElement"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FirstLevelElement::getMaxCdrSerializedSize()); +#else + FirstLevelElement_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FirstLevelElement_max_key_cdr_typesize > 16 ? FirstLevelElement_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FirstLevelElementPubSubType::~FirstLevelElementPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FirstLevelElementPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FirstLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FirstLevelElementPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FirstLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FirstLevelElementPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FirstLevelElementPubSubType::createData() +{ + return reinterpret_cast(new FirstLevelElement()); +} + +void FirstLevelElementPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FirstLevelElementPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FirstLevelElement* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FirstLevelElement_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FirstLevelElement_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FirstLevelElementPubSubType::register_type_object_representation() +{ + register_FirstLevelElement_type_identifier(type_identifiers_); +} + +complex_nested_arraysPubSubType::complex_nested_arraysPubSubType() +{ + setName("complex_nested_arrays"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(complex_nested_arrays::getMaxCdrSerializedSize()); +#else + complex_nested_arrays_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = complex_nested_arrays_max_key_cdr_typesize > 16 ? complex_nested_arrays_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +complex_nested_arraysPubSubType::~complex_nested_arraysPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool complex_nested_arraysPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + complex_nested_arrays* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool complex_nested_arraysPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + complex_nested_arrays* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function complex_nested_arraysPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* complex_nested_arraysPubSubType::createData() +{ + return reinterpret_cast(new complex_nested_arrays()); +} + +void complex_nested_arraysPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool complex_nested_arraysPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + complex_nested_arrays* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + complex_nested_arrays_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || complex_nested_arrays_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void complex_nested_arraysPubSubType::register_type_object_representation() +{ + register_complex_nested_arrays_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "complex_nested_arraysCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h new file mode 100644 index 00000000000..c13439c6e2c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h @@ -0,0 +1,406 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "complex_nested_arrays.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated complex_nested_arrays is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type ThirdLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef ThirdLevelElement type; + + eProsima_user_DllExport ThirdLevelElementPubSubType(); + + eProsima_user_DllExport ~ThirdLevelElementPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type SecondLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef SecondLevelElement type; + + eProsima_user_DllExport SecondLevelElementPubSubType(); + + eProsima_user_DllExport ~SecondLevelElementPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type FirstLevelElement defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FirstLevelElement type; + + eProsima_user_DllExport FirstLevelElementPubSubType(); + + eProsima_user_DllExport ~FirstLevelElementPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type complex_nested_arrays defined by the user in the IDL file. + * @ingroup complex_nested_arrays + */ +class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef complex_nested_arrays type; + + eProsima_user_DllExport complex_nested_arraysPubSubType(); + + eProsima_user_DllExport ~complex_nested_arraysPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx new file mode 100644 index 00000000000..2e9d0cf46b5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx @@ -0,0 +1,493 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "complex_nested_arraysTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "complex_nested_arrays.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ThirdLevelElement_type_identifier( + TypeIdentifierPair& type_ids_ThirdLevelElement) +{ + + ReturnCode_t return_code_ThirdLevelElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ThirdLevelElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdLevelElement", type_ids_ThirdLevelElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ThirdLevelElement) + { + StructTypeFlag struct_flags_ThirdLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ThirdLevelElement = "ThirdLevelElement"; + eprosima::fastcdr::optional type_ann_builtin_ThirdLevelElement; + eprosima::fastcdr::optional ann_custom_ThirdLevelElement; + CompleteTypeDetail detail_ThirdLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ThirdLevelElement, ann_custom_ThirdLevelElement, type_name_ThirdLevelElement.to_string()); + CompleteStructHeader header_ThirdLevelElement; + header_ThirdLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ThirdLevelElement); + CompleteStructMemberSeq member_seq_ThirdLevelElement; + { + TypeIdentifierPair type_ids_x; + ReturnCode_t return_code_x {eprosima::fastdds::dds::RETCODE_OK}; + return_code_x = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_double", type_ids_x); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_x) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "x Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_x = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_x = 0x00000000; + bool common_x_ec {false}; + CommonStructMember common_x {TypeObjectUtils::build_common_struct_member(member_id_x, member_flags_x, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x, common_x_ec))}; + if (!common_x_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x member TypeIdentifier inconsistent."); + return; + } + MemberName name_x = "x"; + eprosima::fastcdr::optional member_ann_builtin_x; + ann_custom_ThirdLevelElement.reset(); + CompleteMemberDetail detail_x = TypeObjectUtils::build_complete_member_detail(name_x, member_ann_builtin_x, ann_custom_ThirdLevelElement); + CompleteStructMember member_x = TypeObjectUtils::build_complete_struct_member(common_x, detail_x); + TypeObjectUtils::add_complete_struct_member(member_seq_ThirdLevelElement, member_x); + } + { + TypeIdentifierPair type_ids_y; + ReturnCode_t return_code_y {eprosima::fastdds::dds::RETCODE_OK}; + return_code_y = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_double", type_ids_y); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_y) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "y Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_y = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_y = 0x00000001; + bool common_y_ec {false}; + CommonStructMember common_y {TypeObjectUtils::build_common_struct_member(member_id_y, member_flags_y, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y, common_y_ec))}; + if (!common_y_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y member TypeIdentifier inconsistent."); + return; + } + MemberName name_y = "y"; + eprosima::fastcdr::optional member_ann_builtin_y; + ann_custom_ThirdLevelElement.reset(); + CompleteMemberDetail detail_y = TypeObjectUtils::build_complete_member_detail(name_y, member_ann_builtin_y, ann_custom_ThirdLevelElement); + CompleteStructMember member_y = TypeObjectUtils::build_complete_struct_member(common_y, detail_y); + TypeObjectUtils::add_complete_struct_member(member_seq_ThirdLevelElement, member_y); + } + CompleteStructType struct_type_ThirdLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_ThirdLevelElement, header_ThirdLevelElement, member_seq_ThirdLevelElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ThirdLevelElement, type_name_ThirdLevelElement.to_string(), type_ids_ThirdLevelElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ThirdLevelElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_SecondLevelElement_type_identifier( + TypeIdentifierPair& type_ids_SecondLevelElement) +{ + + ReturnCode_t return_code_SecondLevelElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_SecondLevelElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SecondLevelElement", type_ids_SecondLevelElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_SecondLevelElement) + { + StructTypeFlag struct_flags_SecondLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_SecondLevelElement = "SecondLevelElement"; + eprosima::fastcdr::optional type_ann_builtin_SecondLevelElement; + eprosima::fastcdr::optional ann_custom_SecondLevelElement; + CompleteTypeDetail detail_SecondLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SecondLevelElement, ann_custom_SecondLevelElement, type_name_SecondLevelElement.to_string()); + CompleteStructHeader header_SecondLevelElement; + header_SecondLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SecondLevelElement); + CompleteStructMemberSeq member_seq_SecondLevelElement; + { + TypeIdentifierPair type_ids_an_element_alone; + ReturnCode_t return_code_an_element_alone {eprosima::fastdds::dds::RETCODE_OK}; + return_code_an_element_alone = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdLevelElement", type_ids_an_element_alone); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_an_element_alone) + { + ::register_ThirdLevelElement_type_identifier(type_ids_an_element_alone); + } + StructMemberFlag member_flags_an_element_alone = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_an_element_alone = 0x00000000; + bool common_an_element_alone_ec {false}; + CommonStructMember common_an_element_alone {TypeObjectUtils::build_common_struct_member(member_id_an_element_alone, member_flags_an_element_alone, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_an_element_alone, common_an_element_alone_ec))}; + if (!common_an_element_alone_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure an_element_alone member TypeIdentifier inconsistent."); + return; + } + MemberName name_an_element_alone = "an_element_alone"; + eprosima::fastcdr::optional member_ann_builtin_an_element_alone; + ann_custom_SecondLevelElement.reset(); + CompleteMemberDetail detail_an_element_alone = TypeObjectUtils::build_complete_member_detail(name_an_element_alone, member_ann_builtin_an_element_alone, ann_custom_SecondLevelElement); + CompleteStructMember member_an_element_alone = TypeObjectUtils::build_complete_struct_member(common_an_element_alone, detail_an_element_alone); + TypeObjectUtils::add_complete_struct_member(member_seq_SecondLevelElement, member_an_element_alone); + } + { + TypeIdentifierPair type_ids_a_limited_other_value; + ReturnCode_t return_code_a_limited_other_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_a_limited_other_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_ThirdLevelElement_1", type_ids_a_limited_other_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_a_limited_other_value) + { + return_code_a_limited_other_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdLevelElement", type_ids_a_limited_other_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_a_limited_other_value) + { + ::register_ThirdLevelElement_type_identifier(type_ids_a_limited_other_value); + } + bool element_identifier_anonymous_sequence_ThirdLevelElement_1_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_ThirdLevelElement_1 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_a_limited_other_value, element_identifier_anonymous_sequence_ThirdLevelElement_1_ec))}; + if (!element_identifier_anonymous_sequence_ThirdLevelElement_1_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_ThirdLevelElement_1 = EK_COMPLETE; + if (TK_NONE == type_ids_a_limited_other_value.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_ThirdLevelElement_1 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_ThirdLevelElement_1 = 0; + PlainCollectionHeader header_anonymous_sequence_ThirdLevelElement_1 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_ThirdLevelElement_1, element_flags_anonymous_sequence_ThirdLevelElement_1); + { + SBound bound = static_cast(1); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_ThirdLevelElement_1, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_ThirdLevelElement_1)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_ThirdLevelElement_1", type_ids_a_limited_other_value)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_ThirdLevelElement_1 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_a_limited_other_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_a_limited_other_value = 0x00000001; + bool common_a_limited_other_value_ec {false}; + CommonStructMember common_a_limited_other_value {TypeObjectUtils::build_common_struct_member(member_id_a_limited_other_value, member_flags_a_limited_other_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_a_limited_other_value, common_a_limited_other_value_ec))}; + if (!common_a_limited_other_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure a_limited_other_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_a_limited_other_value = "a_limited_other_value"; + eprosima::fastcdr::optional member_ann_builtin_a_limited_other_value; + ann_custom_SecondLevelElement.reset(); + CompleteMemberDetail detail_a_limited_other_value = TypeObjectUtils::build_complete_member_detail(name_a_limited_other_value, member_ann_builtin_a_limited_other_value, ann_custom_SecondLevelElement); + CompleteStructMember member_a_limited_other_value = TypeObjectUtils::build_complete_struct_member(common_a_limited_other_value, detail_a_limited_other_value); + TypeObjectUtils::add_complete_struct_member(member_seq_SecondLevelElement, member_a_limited_other_value); + } + CompleteStructType struct_type_SecondLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_SecondLevelElement, header_SecondLevelElement, member_seq_SecondLevelElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_SecondLevelElement, type_name_SecondLevelElement.to_string(), type_ids_SecondLevelElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "SecondLevelElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FirstLevelElement_type_identifier( + TypeIdentifierPair& type_ids_FirstLevelElement) +{ + + ReturnCode_t return_code_FirstLevelElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FirstLevelElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FirstLevelElement", type_ids_FirstLevelElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FirstLevelElement) + { + StructTypeFlag struct_flags_FirstLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_FirstLevelElement = "FirstLevelElement"; + eprosima::fastcdr::optional type_ann_builtin_FirstLevelElement; + eprosima::fastcdr::optional ann_custom_FirstLevelElement; + CompleteTypeDetail detail_FirstLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FirstLevelElement, ann_custom_FirstLevelElement, type_name_FirstLevelElement.to_string()); + CompleteStructHeader header_FirstLevelElement; + header_FirstLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FirstLevelElement); + CompleteStructMemberSeq member_seq_FirstLevelElement; + { + TypeIdentifierPair type_ids_useless_name; + ReturnCode_t return_code_useless_name {eprosima::fastdds::dds::RETCODE_OK}; + return_code_useless_name = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_useless_name); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_useless_name) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_useless_name)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_useless_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_useless_name = 0x00000000; + bool common_useless_name_ec {false}; + CommonStructMember common_useless_name {TypeObjectUtils::build_common_struct_member(member_id_useless_name, member_flags_useless_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_useless_name, common_useless_name_ec))}; + if (!common_useless_name_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure useless_name member TypeIdentifier inconsistent."); + return; + } + MemberName name_useless_name = "useless_name"; + eprosima::fastcdr::optional member_ann_builtin_useless_name; + ann_custom_FirstLevelElement.reset(); + CompleteMemberDetail detail_useless_name = TypeObjectUtils::build_complete_member_detail(name_useless_name, member_ann_builtin_useless_name, ann_custom_FirstLevelElement); + CompleteStructMember member_useless_name = TypeObjectUtils::build_complete_struct_member(common_useless_name, detail_useless_name); + TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_useless_name); + } + { + TypeIdentifierPair type_ids_sub; + ReturnCode_t return_code_sub {eprosima::fastdds::dds::RETCODE_OK}; + return_code_sub = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_SecondLevelElement_unbounded", type_ids_sub); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub) + { + return_code_sub = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SecondLevelElement", type_ids_sub); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub) + { + ::register_SecondLevelElement_type_identifier(type_ids_sub); + } + bool element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_SecondLevelElement_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub, element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_SecondLevelElement_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_sub.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_SecondLevelElement_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_SecondLevelElement_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_SecondLevelElement_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_SecondLevelElement_unbounded, element_flags_anonymous_sequence_SecondLevelElement_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_SecondLevelElement_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_SecondLevelElement_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_SecondLevelElement_unbounded", type_ids_sub)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_SecondLevelElement_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_sub = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_sub = 0x00000001; + bool common_sub_ec {false}; + CommonStructMember common_sub {TypeObjectUtils::build_common_struct_member(member_id_sub, member_flags_sub, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub, common_sub_ec))}; + if (!common_sub_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub member TypeIdentifier inconsistent."); + return; + } + MemberName name_sub = "sub"; + eprosima::fastcdr::optional member_ann_builtin_sub; + ann_custom_FirstLevelElement.reset(); + CompleteMemberDetail detail_sub = TypeObjectUtils::build_complete_member_detail(name_sub, member_ann_builtin_sub, ann_custom_FirstLevelElement); + CompleteStructMember member_sub = TypeObjectUtils::build_complete_struct_member(common_sub, detail_sub); + TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_sub); + } + { + TypeIdentifierPair type_ids_an_element_alone; + ReturnCode_t return_code_an_element_alone {eprosima::fastdds::dds::RETCODE_OK}; + return_code_an_element_alone = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdLevelElement", type_ids_an_element_alone); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_an_element_alone) + { + ::register_ThirdLevelElement_type_identifier(type_ids_an_element_alone); + } + StructMemberFlag member_flags_an_element_alone = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_an_element_alone = 0x00000002; + bool common_an_element_alone_ec {false}; + CommonStructMember common_an_element_alone {TypeObjectUtils::build_common_struct_member(member_id_an_element_alone, member_flags_an_element_alone, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_an_element_alone, common_an_element_alone_ec))}; + if (!common_an_element_alone_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure an_element_alone member TypeIdentifier inconsistent."); + return; + } + MemberName name_an_element_alone = "an_element_alone"; + eprosima::fastcdr::optional member_ann_builtin_an_element_alone; + ann_custom_FirstLevelElement.reset(); + CompleteMemberDetail detail_an_element_alone = TypeObjectUtils::build_complete_member_detail(name_an_element_alone, member_ann_builtin_an_element_alone, ann_custom_FirstLevelElement); + CompleteStructMember member_an_element_alone = TypeObjectUtils::build_complete_struct_member(common_an_element_alone, detail_an_element_alone); + TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_an_element_alone); + } + CompleteStructType struct_type_FirstLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_FirstLevelElement, header_FirstLevelElement, member_seq_FirstLevelElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FirstLevelElement, type_name_FirstLevelElement.to_string(), type_ids_FirstLevelElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FirstLevelElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_complex_nested_arrays_type_identifier( + TypeIdentifierPair& type_ids_complex_nested_arrays) +{ + + ReturnCode_t return_code_complex_nested_arrays {eprosima::fastdds::dds::RETCODE_OK}; + return_code_complex_nested_arrays = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "complex_nested_arrays", type_ids_complex_nested_arrays); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_complex_nested_arrays) + { + StructTypeFlag struct_flags_complex_nested_arrays = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_complex_nested_arrays = "complex_nested_arrays"; + eprosima::fastcdr::optional type_ann_builtin_complex_nested_arrays; + eprosima::fastcdr::optional ann_custom_complex_nested_arrays; + CompleteTypeDetail detail_complex_nested_arrays = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_complex_nested_arrays, ann_custom_complex_nested_arrays, type_name_complex_nested_arrays.to_string()); + CompleteStructHeader header_complex_nested_arrays; + header_complex_nested_arrays = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_complex_nested_arrays); + CompleteStructMemberSeq member_seq_complex_nested_arrays; + { + TypeIdentifierPair type_ids_array_of_elements; + ReturnCode_t return_code_array_of_elements {eprosima::fastdds::dds::RETCODE_OK}; + return_code_array_of_elements = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_FirstLevelElement_3", type_ids_array_of_elements); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_of_elements) + { + return_code_array_of_elements = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FirstLevelElement", type_ids_array_of_elements); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_of_elements) + { + ::register_FirstLevelElement_type_identifier(type_ids_array_of_elements); + } + bool element_identifier_anonymous_array_FirstLevelElement_3_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_FirstLevelElement_3 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_of_elements, element_identifier_anonymous_array_FirstLevelElement_3_ec))}; + if (!element_identifier_anonymous_array_FirstLevelElement_3_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_FirstLevelElement_3 = EK_COMPLETE; + if (TK_NONE == type_ids_array_of_elements.type_identifier2()._d()) + { + equiv_kind_anonymous_array_FirstLevelElement_3 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_FirstLevelElement_3 = 0; + PlainCollectionHeader header_anonymous_array_FirstLevelElement_3 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_FirstLevelElement_3, element_flags_anonymous_array_FirstLevelElement_3); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(3)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_FirstLevelElement_3, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_FirstLevelElement_3)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_FirstLevelElement_3", type_ids_array_of_elements)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_FirstLevelElement_3 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_array_of_elements = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_array_of_elements = 0x00000000; + bool common_array_of_elements_ec {false}; + CommonStructMember common_array_of_elements {TypeObjectUtils::build_common_struct_member(member_id_array_of_elements, member_flags_array_of_elements, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_of_elements, common_array_of_elements_ec))}; + if (!common_array_of_elements_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure array_of_elements member TypeIdentifier inconsistent."); + return; + } + MemberName name_array_of_elements = "array_of_elements"; + eprosima::fastcdr::optional member_ann_builtin_array_of_elements; + ann_custom_complex_nested_arrays.reset(); + CompleteMemberDetail detail_array_of_elements = TypeObjectUtils::build_complete_member_detail(name_array_of_elements, member_ann_builtin_array_of_elements, ann_custom_complex_nested_arrays); + CompleteStructMember member_array_of_elements = TypeObjectUtils::build_complete_struct_member(common_array_of_elements, detail_array_of_elements); + TypeObjectUtils::add_complete_struct_member(member_seq_complex_nested_arrays, member_array_of_elements); + } + CompleteStructType struct_type_complex_nested_arrays = TypeObjectUtils::build_complete_struct_type(struct_flags_complex_nested_arrays, header_complex_nested_arrays, member_seq_complex_nested_arrays); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_complex_nested_arrays, type_name_complex_nested_arrays.to_string(), type_ids_complex_nested_arrays)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "complex_nested_arrays already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp new file mode 100644 index 00000000000..b575368deb8 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp @@ -0,0 +1,92 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file complex_nested_arraysTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register ThirdLevelElement related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ThirdLevelElement_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register SecondLevelElement related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_SecondLevelElement_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register FirstLevelElement related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FirstLevelElement_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register complex_nested_arrays related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_complex_nested_arrays_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp new file mode 100644 index 00000000000..233d3ec45ef --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp @@ -0,0 +1,225 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_ENUM_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(ENUM_STRUCT_SOURCE) +#define ENUM_STRUCT_DllAPI __declspec( dllexport ) +#else +#define ENUM_STRUCT_DllAPI __declspec( dllimport ) +#endif // ENUM_STRUCT_SOURCE +#else +#define ENUM_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define ENUM_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the enumeration ColorEnum defined by the user in the IDL file. + * @ingroup enum_struct + */ +enum class ColorEnum : uint32_t +{ + RED, + GREEN, + BLUE +}; +/*! + * @brief This class represents the structure enum_struct defined by the user in the IDL file. + * @ingroup enum_struct + */ +class enum_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport enum_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~enum_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object enum_struct that will be copied. + */ + eProsima_user_DllExport enum_struct( + const enum_struct& x) + { + m_index = x.m_index; + + m_enum_value = x.m_enum_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object enum_struct that will be copied. + */ + eProsima_user_DllExport enum_struct( + enum_struct&& x) noexcept + { + m_index = x.m_index; + m_enum_value = x.m_enum_value; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object enum_struct that will be copied. + */ + eProsima_user_DllExport enum_struct& operator =( + const enum_struct& x) + { + + m_index = x.m_index; + + m_enum_value = x.m_enum_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object enum_struct that will be copied. + */ + eProsima_user_DllExport enum_struct& operator =( + enum_struct&& x) noexcept + { + + m_index = x.m_index; + m_enum_value = x.m_enum_value; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x enum_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const enum_struct& x) const + { + return (m_index == x.m_index && + m_enum_value == x.m_enum_value); + } + + /*! + * @brief Comparison operator. + * @param x enum_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const enum_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member index + * @param _index New value for member index + */ + eProsima_user_DllExport void index( + uint32_t _index) + { + m_index = _index; + } + + /*! + * @brief This function returns the value of member index + * @return Value of member index + */ + eProsima_user_DllExport uint32_t index() const + { + return m_index; + } + + /*! + * @brief This function returns a reference to member index + * @return Reference to member index + */ + eProsima_user_DllExport uint32_t& index() + { + return m_index; + } + + + /*! + * @brief This function sets a value in member enum_value + * @param _enum_value New value for member enum_value + */ + eProsima_user_DllExport void enum_value( + ColorEnum _enum_value) + { + m_enum_value = _enum_value; + } + + /*! + * @brief This function returns the value of member enum_value + * @return Value of member enum_value + */ + eProsima_user_DllExport ColorEnum enum_value() const + { + return m_enum_value; + } + + /*! + * @brief This function returns a reference to member enum_value + * @return Reference to member enum_value + */ + eProsima_user_DllExport ColorEnum& enum_value() + { + return m_enum_value; + } + + + +private: + + uint32_t m_index{0}; + ColorEnum m_enum_value{ColorEnum::RED}; + +}; + +#endif // _FAST_DDS_GENERATED_ENUM_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp new file mode 100644 index 00000000000..9e1aa3673f6 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp @@ -0,0 +1,47 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ + +#include "enum_struct.hpp" + +constexpr uint32_t enum_struct_max_cdr_typesize {12UL}; +constexpr uint32_t enum_struct_max_key_cdr_typesize {0UL}; + + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const enum_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp new file mode 100644 index 00000000000..28ac17b0ff5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp @@ -0,0 +1,126 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ + +#include "enum_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const enum_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.index(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.enum_value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const enum_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.index() + << eprosima::fastcdr::MemberId(1) << data.enum_value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + enum_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.index(); + break; + + case 1: + dcdr >> data.enum_value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const enum_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx new file mode 100644 index 00000000000..179fd591e64 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "enum_structPubSubTypes.h" + +#include +#include + +#include "enum_structCdrAux.hpp" +#include "enum_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +enum_structPubSubType::enum_structPubSubType() +{ + setName("enum_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(enum_struct::getMaxCdrSerializedSize()); +#else + enum_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = enum_struct_max_key_cdr_typesize > 16 ? enum_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +enum_structPubSubType::~enum_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool enum_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + enum_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool enum_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + enum_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function enum_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* enum_structPubSubType::createData() +{ + return reinterpret_cast(new enum_struct()); +} + +void enum_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool enum_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + enum_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + enum_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || enum_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void enum_structPubSubType::register_type_object_representation() +{ + register_enum_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "enum_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h new file mode 100644 index 00000000000..435b7600694 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "enum_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated enum_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type enum_struct defined by the user in the IDL file. + * @ingroup enum_struct + */ +class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef enum_struct type; + + eProsima_user_DllExport enum_structPubSubType(); + + eProsima_user_DllExport ~enum_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..642e3524470 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx @@ -0,0 +1,185 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "enum_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "enum_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +void register_ColorEnum_type_identifier( + TypeIdentifierPair& type_ids_ColorEnum) +{ + ReturnCode_t return_code_ColorEnum {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ColorEnum = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorEnum", type_ids_ColorEnum); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ColorEnum) + { + EnumTypeFlag enum_flags_ColorEnum = 0; + BitBound bit_bound_ColorEnum = 32; + CommonEnumeratedHeader common_ColorEnum = TypeObjectUtils::build_common_enumerated_header(bit_bound_ColorEnum); + QualifiedTypeName type_name_ColorEnum = "ColorEnum"; + eprosima::fastcdr::optional type_ann_builtin_ColorEnum; + eprosima::fastcdr::optional ann_custom_ColorEnum; + CompleteTypeDetail detail_ColorEnum = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ColorEnum, ann_custom_ColorEnum, type_name_ColorEnum.to_string()); + CompleteEnumeratedHeader header_ColorEnum = TypeObjectUtils::build_complete_enumerated_header(common_ColorEnum, detail_ColorEnum); + CompleteEnumeratedLiteralSeq literal_seq_ColorEnum; + { + EnumeratedLiteralFlag flags_RED = TypeObjectUtils::build_enumerated_literal_flag(false); + CommonEnumeratedLiteral common_RED = TypeObjectUtils::build_common_enumerated_literal(0, flags_RED); + eprosima::fastcdr::optional member_ann_builtin_RED; + ann_custom_ColorEnum.reset(); + MemberName name_RED = "RED"; + CompleteMemberDetail detail_RED = TypeObjectUtils::build_complete_member_detail(name_RED, member_ann_builtin_RED, ann_custom_ColorEnum); + CompleteEnumeratedLiteral literal_RED = TypeObjectUtils::build_complete_enumerated_literal(common_RED, detail_RED); + TypeObjectUtils::add_complete_enumerated_literal(literal_seq_ColorEnum, literal_RED); + } + { + EnumeratedLiteralFlag flags_GREEN = TypeObjectUtils::build_enumerated_literal_flag(false); + CommonEnumeratedLiteral common_GREEN = TypeObjectUtils::build_common_enumerated_literal(1, flags_GREEN); + eprosima::fastcdr::optional member_ann_builtin_GREEN; + ann_custom_ColorEnum.reset(); + MemberName name_GREEN = "GREEN"; + CompleteMemberDetail detail_GREEN = TypeObjectUtils::build_complete_member_detail(name_GREEN, member_ann_builtin_GREEN, ann_custom_ColorEnum); + CompleteEnumeratedLiteral literal_GREEN = TypeObjectUtils::build_complete_enumerated_literal(common_GREEN, detail_GREEN); + TypeObjectUtils::add_complete_enumerated_literal(literal_seq_ColorEnum, literal_GREEN); + } + { + EnumeratedLiteralFlag flags_BLUE = TypeObjectUtils::build_enumerated_literal_flag(false); + CommonEnumeratedLiteral common_BLUE = TypeObjectUtils::build_common_enumerated_literal(2, flags_BLUE); + eprosima::fastcdr::optional member_ann_builtin_BLUE; + ann_custom_ColorEnum.reset(); + MemberName name_BLUE = "BLUE"; + CompleteMemberDetail detail_BLUE = TypeObjectUtils::build_complete_member_detail(name_BLUE, member_ann_builtin_BLUE, ann_custom_ColorEnum); + CompleteEnumeratedLiteral literal_BLUE = TypeObjectUtils::build_complete_enumerated_literal(common_BLUE, detail_BLUE); + TypeObjectUtils::add_complete_enumerated_literal(literal_seq_ColorEnum, literal_BLUE); + } + CompleteEnumeratedType enumerated_type_ColorEnum = TypeObjectUtils::build_complete_enumerated_type(enum_flags_ColorEnum, header_ColorEnum, + literal_seq_ColorEnum); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_enumerated_type_object(enumerated_type_ColorEnum, type_name_ColorEnum.to_string(), type_ids_ColorEnum)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ColorEnum already registered in TypeObjectRegistry for a different type."); + } + } +}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_enum_struct_type_identifier( + TypeIdentifierPair& type_ids_enum_struct) +{ + + ReturnCode_t return_code_enum_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_enum_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "enum_struct", type_ids_enum_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_enum_struct) + { + StructTypeFlag struct_flags_enum_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_enum_struct = "enum_struct"; + eprosima::fastcdr::optional type_ann_builtin_enum_struct; + eprosima::fastcdr::optional ann_custom_enum_struct; + CompleteTypeDetail detail_enum_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_enum_struct, ann_custom_enum_struct, type_name_enum_struct.to_string()); + CompleteStructHeader header_enum_struct; + header_enum_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_enum_struct); + CompleteStructMemberSeq member_seq_enum_struct; + { + TypeIdentifierPair type_ids_index; + ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; + return_code_index = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_index); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_index = 0x00000000; + bool common_index_ec {false}; + CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; + if (!common_index_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); + return; + } + MemberName name_index = "index"; + eprosima::fastcdr::optional member_ann_builtin_index; + ann_custom_enum_struct.reset(); + CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_enum_struct); + CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); + TypeObjectUtils::add_complete_struct_member(member_seq_enum_struct, member_index); + } + { + TypeIdentifierPair type_ids_enum_value; + ReturnCode_t return_code_enum_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_enum_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorEnum", type_ids_enum_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_enum_value) + { + ::register_ColorEnum_type_identifier(type_ids_enum_value); + } + StructMemberFlag member_flags_enum_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_enum_value = 0x00000001; + bool common_enum_value_ec {false}; + CommonStructMember common_enum_value {TypeObjectUtils::build_common_struct_member(member_id_enum_value, member_flags_enum_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum_value, common_enum_value_ec))}; + if (!common_enum_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure enum_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_enum_value = "enum_value"; + eprosima::fastcdr::optional member_ann_builtin_enum_value; + ann_custom_enum_struct.reset(); + CompleteMemberDetail detail_enum_value = TypeObjectUtils::build_complete_member_detail(name_enum_value, member_ann_builtin_enum_value, ann_custom_enum_struct); + CompleteStructMember member_enum_value = TypeObjectUtils::build_complete_struct_member(common_enum_value, detail_enum_value); + TypeObjectUtils::add_complete_struct_member(member_seq_enum_struct, member_enum_value); + } + CompleteStructType struct_type_enum_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_enum_struct, header_enum_struct, member_seq_enum_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_enum_struct, type_name_enum_struct.to_string(), type_ids_enum_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "enum_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..288179a215a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file enum_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register ColorEnum related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ColorEnum_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register enum_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_enum_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp new file mode 100644 index 00000000000..983bb95d5bd --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp @@ -0,0 +1,190 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequence.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ +#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ + +#include +#include +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(FLOAT_BOUNDED_SEQUENCE_SOURCE) +#define FLOAT_BOUNDED_SEQUENCE_DllAPI __declspec( dllexport ) +#else +#define FLOAT_BOUNDED_SEQUENCE_DllAPI __declspec( dllimport ) +#endif // FLOAT_BOUNDED_SEQUENCE_SOURCE +#else +#define FLOAT_BOUNDED_SEQUENCE_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define FLOAT_BOUNDED_SEQUENCE_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure float_bounded_sequence defined by the user in the IDL file. + * @ingroup float_bounded_sequence + */ +class float_bounded_sequence +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport float_bounded_sequence() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~float_bounded_sequence() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object float_bounded_sequence that will be copied. + */ + eProsima_user_DllExport float_bounded_sequence( + const float_bounded_sequence& x) + { + m_numbers = x.m_numbers; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object float_bounded_sequence that will be copied. + */ + eProsima_user_DllExport float_bounded_sequence( + float_bounded_sequence&& x) noexcept + { + m_numbers = std::move(x.m_numbers); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object float_bounded_sequence that will be copied. + */ + eProsima_user_DllExport float_bounded_sequence& operator =( + const float_bounded_sequence& x) + { + + m_numbers = x.m_numbers; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object float_bounded_sequence that will be copied. + */ + eProsima_user_DllExport float_bounded_sequence& operator =( + float_bounded_sequence&& x) noexcept + { + + m_numbers = std::move(x.m_numbers); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x float_bounded_sequence object to compare. + */ + eProsima_user_DllExport bool operator ==( + const float_bounded_sequence& x) const + { + return (m_numbers == x.m_numbers); + } + + /*! + * @brief Comparison operator. + * @param x float_bounded_sequence object to compare. + */ + eProsima_user_DllExport bool operator !=( + const float_bounded_sequence& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member numbers + * @param _numbers New value to be copied in member numbers + */ + eProsima_user_DllExport void numbers( + const std::vector& _numbers) + { + m_numbers = _numbers; + } + + /*! + * @brief This function moves the value in member numbers + * @param _numbers New value to be moved in member numbers + */ + eProsima_user_DllExport void numbers( + std::vector&& _numbers) + { + m_numbers = std::move(_numbers); + } + + /*! + * @brief This function returns a constant reference to member numbers + * @return Constant reference to member numbers + */ + eProsima_user_DllExport const std::vector& numbers() const + { + return m_numbers; + } + + /*! + * @brief This function returns a reference to member numbers + * @return Reference to member numbers + */ + eProsima_user_DllExport std::vector& numbers() + { + return m_numbers; + } + + + +private: + + std::vector m_numbers; + +}; + +#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp new file mode 100644 index 00000000000..432e90292a2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequenceCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ +#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ + +#include "float_bounded_sequence.hpp" + +constexpr uint32_t float_bounded_sequence_max_cdr_typesize {60UL}; +constexpr uint32_t float_bounded_sequence_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const float_bounded_sequence& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp new file mode 100644 index 00000000000..9903c5579b5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequenceCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ +#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ + +#include "float_bounded_sequenceCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const float_bounded_sequence& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.numbers(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const float_bounded_sequence& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.numbers() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + float_bounded_sequence& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.numbers(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const float_bounded_sequence& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx new file mode 100644 index 00000000000..1d4ead5615c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequencePubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "float_bounded_sequencePubSubTypes.h" + +#include +#include + +#include "float_bounded_sequenceCdrAux.hpp" +#include "float_bounded_sequenceTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +float_bounded_sequencePubSubType::float_bounded_sequencePubSubType() +{ + setName("float_bounded_sequence"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(float_bounded_sequence::getMaxCdrSerializedSize()); +#else + float_bounded_sequence_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = float_bounded_sequence_max_key_cdr_typesize > 16 ? float_bounded_sequence_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +float_bounded_sequencePubSubType::~float_bounded_sequencePubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool float_bounded_sequencePubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + float_bounded_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool float_bounded_sequencePubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + float_bounded_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function float_bounded_sequencePubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* float_bounded_sequencePubSubType::createData() +{ + return reinterpret_cast(new float_bounded_sequence()); +} + +void float_bounded_sequencePubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool float_bounded_sequencePubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + float_bounded_sequence* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + float_bounded_sequence_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || float_bounded_sequence_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void float_bounded_sequencePubSubType::register_type_object_representation() +{ + register_float_bounded_sequence_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "float_bounded_sequenceCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h new file mode 100644 index 00000000000..9d4387779c7 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequencePubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "float_bounded_sequence.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated float_bounded_sequence is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type float_bounded_sequence defined by the user in the IDL file. + * @ingroup float_bounded_sequence + */ +class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef float_bounded_sequence type; + + eProsima_user_DllExport float_bounded_sequencePubSubType(); + + eProsima_user_DllExport ~float_bounded_sequencePubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx new file mode 100644 index 00000000000..aa6108f64ac --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx @@ -0,0 +1,132 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequenceTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "float_bounded_sequenceTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "float_bounded_sequence.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_float_bounded_sequence_type_identifier( + TypeIdentifierPair& type_ids_float_bounded_sequence) +{ + + ReturnCode_t return_code_float_bounded_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_float_bounded_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "float_bounded_sequence", type_ids_float_bounded_sequence); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_float_bounded_sequence) + { + StructTypeFlag struct_flags_float_bounded_sequence = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_float_bounded_sequence = "float_bounded_sequence"; + eprosima::fastcdr::optional type_ann_builtin_float_bounded_sequence; + eprosima::fastcdr::optional ann_custom_float_bounded_sequence; + CompleteTypeDetail detail_float_bounded_sequence = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_float_bounded_sequence, ann_custom_float_bounded_sequence, type_name_float_bounded_sequence.to_string()); + CompleteStructHeader header_float_bounded_sequence; + header_float_bounded_sequence = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_float_bounded_sequence); + CompleteStructMemberSeq member_seq_float_bounded_sequence; + { + TypeIdentifierPair type_ids_numbers; + ReturnCode_t return_code_numbers {eprosima::fastdds::dds::RETCODE_OK}; + return_code_numbers = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_float_13", type_ids_numbers); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_numbers) + { + return_code_numbers = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_float", type_ids_numbers); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_numbers) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_sequence_float_13_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_float_13 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_numbers, element_identifier_anonymous_sequence_float_13_ec))}; + if (!element_identifier_anonymous_sequence_float_13_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_float_13 = EK_COMPLETE; + if (TK_NONE == type_ids_numbers.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_float_13 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_float_13 = 0; + PlainCollectionHeader header_anonymous_sequence_float_13 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_float_13, element_flags_anonymous_sequence_float_13); + { + SBound bound = static_cast(13); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_float_13, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_float_13)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_float_13", type_ids_numbers)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_float_13 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_numbers = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_numbers = 0x00000000; + bool common_numbers_ec {false}; + CommonStructMember common_numbers {TypeObjectUtils::build_common_struct_member(member_id_numbers, member_flags_numbers, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_numbers, common_numbers_ec))}; + if (!common_numbers_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure numbers member TypeIdentifier inconsistent."); + return; + } + MemberName name_numbers = "numbers"; + eprosima::fastcdr::optional member_ann_builtin_numbers; + ann_custom_float_bounded_sequence.reset(); + CompleteMemberDetail detail_numbers = TypeObjectUtils::build_complete_member_detail(name_numbers, member_ann_builtin_numbers, ann_custom_float_bounded_sequence); + CompleteStructMember member_numbers = TypeObjectUtils::build_complete_struct_member(common_numbers, detail_numbers); + TypeObjectUtils::add_complete_struct_member(member_seq_float_bounded_sequence, member_numbers); + } + CompleteStructType struct_type_float_bounded_sequence = TypeObjectUtils::build_complete_struct_type(struct_flags_float_bounded_sequence, header_float_bounded_sequence, member_seq_float_bounded_sequence); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_float_bounded_sequence, type_name_float_bounded_sequence.to_string(), type_ids_float_bounded_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "float_bounded_sequence already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp new file mode 100644 index 00000000000..bdf598769b3 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file float_bounded_sequenceTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register float_bounded_sequence related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_float_bounded_sequence_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp new file mode 100644 index 00000000000..282793dd764 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp @@ -0,0 +1,227 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_world.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ +#define _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ + +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(HELLO_WORLD_SOURCE) +#define HELLO_WORLD_DllAPI __declspec( dllexport ) +#else +#define HELLO_WORLD_DllAPI __declspec( dllimport ) +#endif // HELLO_WORLD_SOURCE +#else +#define HELLO_WORLD_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define HELLO_WORLD_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure hello_world defined by the user in the IDL file. + * @ingroup hello_world + */ +class hello_world +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport hello_world() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~hello_world() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object hello_world that will be copied. + */ + eProsima_user_DllExport hello_world( + const hello_world& x) + { + m_index = x.m_index; + + m_message = x.m_message; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object hello_world that will be copied. + */ + eProsima_user_DllExport hello_world( + hello_world&& x) noexcept + { + m_index = x.m_index; + m_message = std::move(x.m_message); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object hello_world that will be copied. + */ + eProsima_user_DllExport hello_world& operator =( + const hello_world& x) + { + + m_index = x.m_index; + + m_message = x.m_message; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object hello_world that will be copied. + */ + eProsima_user_DllExport hello_world& operator =( + hello_world&& x) noexcept + { + + m_index = x.m_index; + m_message = std::move(x.m_message); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x hello_world object to compare. + */ + eProsima_user_DllExport bool operator ==( + const hello_world& x) const + { + return (m_index == x.m_index && + m_message == x.m_message); + } + + /*! + * @brief Comparison operator. + * @param x hello_world object to compare. + */ + eProsima_user_DllExport bool operator !=( + const hello_world& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member index + * @param _index New value for member index + */ + eProsima_user_DllExport void index( + uint32_t _index) + { + m_index = _index; + } + + /*! + * @brief This function returns the value of member index + * @return Value of member index + */ + eProsima_user_DllExport uint32_t index() const + { + return m_index; + } + + /*! + * @brief This function returns a reference to member index + * @return Reference to member index + */ + eProsima_user_DllExport uint32_t& index() + { + return m_index; + } + + + /*! + * @brief This function copies the value in member message + * @param _message New value to be copied in member message + */ + eProsima_user_DllExport void message( + const std::string& _message) + { + m_message = _message; + } + + /*! + * @brief This function moves the value in member message + * @param _message New value to be moved in member message + */ + eProsima_user_DllExport void message( + std::string&& _message) + { + m_message = std::move(_message); + } + + /*! + * @brief This function returns a constant reference to member message + * @return Constant reference to member message + */ + eProsima_user_DllExport const std::string& message() const + { + return m_message; + } + + /*! + * @brief This function returns a reference to member message + * @return Reference to member message + */ + eProsima_user_DllExport std::string& message() + { + return m_message; + } + + + +private: + + uint32_t m_index{0}; + std::string m_message; + +}; + +#endif // _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp new file mode 100644 index 00000000000..80a73b13314 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ + +#include "hello_world.hpp" + +constexpr uint32_t hello_world_max_cdr_typesize {268UL}; +constexpr uint32_t hello_world_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const hello_world& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp new file mode 100644 index 00000000000..1f22846bccd --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp @@ -0,0 +1,126 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ + +#include "hello_worldCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const hello_world& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.index(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.message(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const hello_world& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.index() + << eprosima::fastcdr::MemberId(1) << data.message() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + hello_world& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.index(); + break; + + case 1: + dcdr >> data.message(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const hello_world& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx new file mode 100644 index 00000000000..7cdb1683a54 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "hello_worldPubSubTypes.h" + +#include +#include + +#include "hello_worldCdrAux.hpp" +#include "hello_worldTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +hello_worldPubSubType::hello_worldPubSubType() +{ + setName("hello_world"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(hello_world::getMaxCdrSerializedSize()); +#else + hello_world_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = hello_world_max_key_cdr_typesize > 16 ? hello_world_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +hello_worldPubSubType::~hello_worldPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool hello_worldPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + hello_world* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool hello_worldPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + hello_world* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function hello_worldPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* hello_worldPubSubType::createData() +{ + return reinterpret_cast(new hello_world()); +} + +void hello_worldPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool hello_worldPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + hello_world* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + hello_world_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || hello_world_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void hello_worldPubSubType::register_type_object_representation() +{ + register_hello_world_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "hello_worldCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h new file mode 100644 index 00000000000..df55176d36c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "hello_world.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated hello_world is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type hello_world defined by the user in the IDL file. + * @ingroup hello_world + */ +class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef hello_world type; + + eProsima_user_DllExport hello_worldPubSubType(); + + eProsima_user_DllExport ~hello_worldPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx new file mode 100644 index 00000000000..1c19ab8195f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx @@ -0,0 +1,138 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "hello_worldTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "hello_world.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_hello_world_type_identifier( + TypeIdentifierPair& type_ids_hello_world) +{ + + ReturnCode_t return_code_hello_world {eprosima::fastdds::dds::RETCODE_OK}; + return_code_hello_world = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "hello_world", type_ids_hello_world); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_hello_world) + { + StructTypeFlag struct_flags_hello_world = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_hello_world = "hello_world"; + eprosima::fastcdr::optional type_ann_builtin_hello_world; + eprosima::fastcdr::optional ann_custom_hello_world; + CompleteTypeDetail detail_hello_world = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_hello_world, ann_custom_hello_world, type_name_hello_world.to_string()); + CompleteStructHeader header_hello_world; + header_hello_world = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_hello_world); + CompleteStructMemberSeq member_seq_hello_world; + { + TypeIdentifierPair type_ids_index; + ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; + return_code_index = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_index); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_index = 0x00000000; + bool common_index_ec {false}; + CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; + if (!common_index_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); + return; + } + MemberName name_index = "index"; + eprosima::fastcdr::optional member_ann_builtin_index; + ann_custom_hello_world.reset(); + CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_hello_world); + CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); + TypeObjectUtils::add_complete_struct_member(member_seq_hello_world, member_index); + } + { + TypeIdentifierPair type_ids_message; + ReturnCode_t return_code_message {eprosima::fastdds::dds::RETCODE_OK}; + return_code_message = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_message); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_message) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_message)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_message = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_message = 0x00000001; + bool common_message_ec {false}; + CommonStructMember common_message {TypeObjectUtils::build_common_struct_member(member_id_message, member_flags_message, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message, common_message_ec))}; + if (!common_message_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message member TypeIdentifier inconsistent."); + return; + } + MemberName name_message = "message"; + eprosima::fastcdr::optional member_ann_builtin_message; + ann_custom_hello_world.reset(); + CompleteMemberDetail detail_message = TypeObjectUtils::build_complete_member_detail(name_message, member_ann_builtin_message, ann_custom_hello_world); + CompleteStructMember member_message = TypeObjectUtils::build_complete_struct_member(common_message, detail_message); + TypeObjectUtils::add_complete_struct_member(member_seq_hello_world, member_message); + } + CompleteStructType struct_type_hello_world = TypeObjectUtils::build_complete_struct_type(struct_flags_hello_world, header_hello_world, member_seq_hello_world); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_hello_world, type_name_hello_world.to_string(), type_ids_hello_world)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "hello_world already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp new file mode 100644 index 00000000000..dcf5d1a65c0 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file hello_worldTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register hello_world related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_hello_world_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp new file mode 100644 index 00000000000..bbc4bdc89c5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp @@ -0,0 +1,191 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_MAP_STRUCT_HPP_ + +#include +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(MAP_STRUCT_SOURCE) +#define MAP_STRUCT_DllAPI __declspec( dllexport ) +#else +#define MAP_STRUCT_DllAPI __declspec( dllimport ) +#endif // MAP_STRUCT_SOURCE +#else +#define MAP_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define MAP_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure map_struct defined by the user in the IDL file. + * @ingroup map_struct + */ +class map_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport map_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~map_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object map_struct that will be copied. + */ + eProsima_user_DllExport map_struct( + const map_struct& x) + { + m_my_map = x.m_my_map; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object map_struct that will be copied. + */ + eProsima_user_DllExport map_struct( + map_struct&& x) noexcept + { + m_my_map = std::move(x.m_my_map); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object map_struct that will be copied. + */ + eProsima_user_DllExport map_struct& operator =( + const map_struct& x) + { + + m_my_map = x.m_my_map; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object map_struct that will be copied. + */ + eProsima_user_DllExport map_struct& operator =( + map_struct&& x) noexcept + { + + m_my_map = std::move(x.m_my_map); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x map_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const map_struct& x) const + { + return (m_my_map == x.m_my_map); + } + + /*! + * @brief Comparison operator. + * @param x map_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const map_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_map + * @param _my_map New value to be copied in member my_map + */ + eProsima_user_DllExport void my_map( + const std::map& _my_map) + { + m_my_map = _my_map; + } + + /*! + * @brief This function moves the value in member my_map + * @param _my_map New value to be moved in member my_map + */ + eProsima_user_DllExport void my_map( + std::map&& _my_map) + { + m_my_map = std::move(_my_map); + } + + /*! + * @brief This function returns a constant reference to member my_map + * @return Constant reference to member my_map + */ + eProsima_user_DllExport const std::map& my_map() const + { + return m_my_map; + } + + /*! + * @brief This function returns a reference to member my_map + * @return Reference to member my_map + */ + eProsima_user_DllExport std::map& my_map() + { + return m_my_map; + } + + + +private: + + std::map m_my_map; + +}; + +#endif // _FAST_DDS_GENERATED_MAP_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp new file mode 100644 index 00000000000..be6fde96e3c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ + +#include "map_struct.hpp" + +constexpr uint32_t map_struct_max_cdr_typesize {8UL}; +constexpr uint32_t map_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const map_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp new file mode 100644 index 00000000000..e49ea33b9f0 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ + +#include "map_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const map_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_map(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const map_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_map() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + map_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_map(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const map_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx new file mode 100644 index 00000000000..464284052f8 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "map_structPubSubTypes.h" + +#include +#include + +#include "map_structCdrAux.hpp" +#include "map_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +map_structPubSubType::map_structPubSubType() +{ + setName("map_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(map_struct::getMaxCdrSerializedSize()); +#else + map_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = map_struct_max_key_cdr_typesize > 16 ? map_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +map_structPubSubType::~map_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool map_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + map_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool map_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + map_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function map_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* map_structPubSubType::createData() +{ + return reinterpret_cast(new map_struct()); +} + +void map_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool map_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + map_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + map_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || map_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void map_structPubSubType::register_type_object_representation() +{ + register_map_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "map_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h new file mode 100644 index 00000000000..72cd07deca5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "map_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated map_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type map_struct defined by the user in the IDL file. + * @ingroup map_struct + */ +class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef map_struct type; + + eProsima_user_DllExport map_structPubSubType(); + + eProsima_user_DllExport ~map_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..e4d4e981bc3 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx @@ -0,0 +1,167 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "map_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "map_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_map_struct_type_identifier( + TypeIdentifierPair& type_ids_map_struct) +{ + + ReturnCode_t return_code_map_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_map_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "map_struct", type_ids_map_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_map_struct) + { + StructTypeFlag struct_flags_map_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_map_struct = "map_struct"; + eprosima::fastcdr::optional type_ann_builtin_map_struct; + eprosima::fastcdr::optional ann_custom_map_struct; + CompleteTypeDetail detail_map_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_map_struct, ann_custom_map_struct, type_name_map_struct.to_string()); + CompleteStructHeader header_map_struct; + header_map_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_map_struct); + CompleteStructMemberSeq member_seq_map_struct; + { + TypeIdentifierPair type_ids_my_map; + ReturnCode_t return_code_my_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Map element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; + if (!element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_unbounded inconsistent element TypeIdentifier."); + return; + } + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + bool key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec {false}; + TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; + if (!key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_unbounded inconsistent key TypeIdentifier."); + return; + } + EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_bool_unbounded = EK_BOTH; + if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d()) || + (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->seq_sdefn().header().equiv_kind()) || + (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->seq_ldefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->array_sdefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->array_ldefn().header().equiv_kind()) || + (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->map_sdefn().header().equiv_kind())) || + (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded->map_ldefn().header().equiv_kind()))) + { + equiv_kind_anonymous_map_anonymous_string_unbounded_bool_unbounded = EK_COMPLETE; + } + CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_bool_unbounded = 0; + CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_bool_unbounded = 0; + PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_bool_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_bool_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_bool_unbounded); + { + SBound bound = 0; + PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_bool_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_bool_unbounded, + eprosima::fastcdr::external(key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_map = 0x00000000; + bool common_my_map_ec {false}; + CommonStructMember common_my_map {TypeObjectUtils::build_common_struct_member(member_id_my_map, member_flags_my_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, common_my_map_ec))}; + if (!common_my_map_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_map member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_map = "my_map"; + eprosima::fastcdr::optional member_ann_builtin_my_map; + ann_custom_map_struct.reset(); + CompleteMemberDetail detail_my_map = TypeObjectUtils::build_complete_member_detail(name_my_map, member_ann_builtin_my_map, ann_custom_map_struct); + CompleteStructMember member_my_map = TypeObjectUtils::build_complete_struct_member(common_my_map, detail_my_map); + TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_map); + } + CompleteStructType struct_type_map_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_map_struct, header_map_struct, member_seq_map_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_map_struct, type_name_map_struct.to_string(), type_ids_map_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "map_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..c0af3f4f51c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register map_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_map_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp new file mode 100644 index 00000000000..7ae80c45853 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp @@ -0,0 +1,189 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_array.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ +#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ + +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(NUMERIC_ARRAY_SOURCE) +#define NUMERIC_ARRAY_DllAPI __declspec( dllexport ) +#else +#define NUMERIC_ARRAY_DllAPI __declspec( dllimport ) +#endif // NUMERIC_ARRAY_SOURCE +#else +#define NUMERIC_ARRAY_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define NUMERIC_ARRAY_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure numeric_array defined by the user in the IDL file. + * @ingroup numeric_array + */ +class numeric_array +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport numeric_array() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~numeric_array() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object numeric_array that will be copied. + */ + eProsima_user_DllExport numeric_array( + const numeric_array& x) + { + m_points = x.m_points; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object numeric_array that will be copied. + */ + eProsima_user_DllExport numeric_array( + numeric_array&& x) noexcept + { + m_points = std::move(x.m_points); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object numeric_array that will be copied. + */ + eProsima_user_DllExport numeric_array& operator =( + const numeric_array& x) + { + + m_points = x.m_points; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object numeric_array that will be copied. + */ + eProsima_user_DllExport numeric_array& operator =( + numeric_array&& x) noexcept + { + + m_points = std::move(x.m_points); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x numeric_array object to compare. + */ + eProsima_user_DllExport bool operator ==( + const numeric_array& x) const + { + return (m_points == x.m_points); + } + + /*! + * @brief Comparison operator. + * @param x numeric_array object to compare. + */ + eProsima_user_DllExport bool operator !=( + const numeric_array& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member points + * @param _points New value to be copied in member points + */ + eProsima_user_DllExport void points( + const std::array& _points) + { + m_points = _points; + } + + /*! + * @brief This function moves the value in member points + * @param _points New value to be moved in member points + */ + eProsima_user_DllExport void points( + std::array&& _points) + { + m_points = std::move(_points); + } + + /*! + * @brief This function returns a constant reference to member points + * @return Constant reference to member points + */ + eProsima_user_DllExport const std::array& points() const + { + return m_points; + } + + /*! + * @brief This function returns a reference to member points + * @return Reference to member points + */ + eProsima_user_DllExport std::array& points() + { + return m_points; + } + + + +private: + + std::array m_points{0}; + +}; + +#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp new file mode 100644 index 00000000000..a058c1a8b0b --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ + +#include "numeric_array.hpp" + +constexpr uint32_t numeric_array_max_cdr_typesize {16UL}; +constexpr uint32_t numeric_array_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const numeric_array& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp new file mode 100644 index 00000000000..41c1c7ad72a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ + +#include "numeric_arrayCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const numeric_array& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.points(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const numeric_array& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.points() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + numeric_array& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.points(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const numeric_array& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx new file mode 100644 index 00000000000..47db4f96f2d --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "numeric_arrayPubSubTypes.h" + +#include +#include + +#include "numeric_arrayCdrAux.hpp" +#include "numeric_arrayTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +numeric_arrayPubSubType::numeric_arrayPubSubType() +{ + setName("numeric_array"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(numeric_array::getMaxCdrSerializedSize()); +#else + numeric_array_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = numeric_array_max_key_cdr_typesize > 16 ? numeric_array_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +numeric_arrayPubSubType::~numeric_arrayPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool numeric_arrayPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + numeric_array* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool numeric_arrayPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + numeric_array* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function numeric_arrayPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* numeric_arrayPubSubType::createData() +{ + return reinterpret_cast(new numeric_array()); +} + +void numeric_arrayPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool numeric_arrayPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + numeric_array* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + numeric_array_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || numeric_array_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void numeric_arrayPubSubType::register_type_object_representation() +{ + register_numeric_array_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "numeric_arrayCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h new file mode 100644 index 00000000000..235d77b7993 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "numeric_array.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated numeric_array is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type numeric_array defined by the user in the IDL file. + * @ingroup numeric_array + */ +class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef numeric_array type; + + eProsima_user_DllExport numeric_arrayPubSubType(); + + eProsima_user_DllExport ~numeric_arrayPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx new file mode 100644 index 00000000000..22b35f279c1 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx @@ -0,0 +1,134 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "numeric_arrayTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "numeric_array.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_numeric_array_type_identifier( + TypeIdentifierPair& type_ids_numeric_array) +{ + + ReturnCode_t return_code_numeric_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_numeric_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "numeric_array", type_ids_numeric_array); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_numeric_array) + { + StructTypeFlag struct_flags_numeric_array = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_numeric_array = "numeric_array"; + eprosima::fastcdr::optional type_ann_builtin_numeric_array; + eprosima::fastcdr::optional ann_custom_numeric_array; + CompleteTypeDetail detail_numeric_array = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_numeric_array, ann_custom_numeric_array, type_name_numeric_array.to_string()); + CompleteStructHeader header_numeric_array; + header_numeric_array = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_numeric_array); + CompleteStructMemberSeq member_seq_numeric_array; + { + TypeIdentifierPair type_ids_points; + ReturnCode_t return_code_points {eprosima::fastdds::dds::RETCODE_OK}; + return_code_points = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_int32_t_3", type_ids_points); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_points) + { + return_code_points = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_points); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_points) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Array element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_array_int32_t_3_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_int32_t_3 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_points, element_identifier_anonymous_array_int32_t_3_ec))}; + if (!element_identifier_anonymous_array_int32_t_3_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_int32_t_3 = EK_COMPLETE; + if (TK_NONE == type_ids_points.type_identifier2()._d()) + { + equiv_kind_anonymous_array_int32_t_3 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_int32_t_3 = 0; + PlainCollectionHeader header_anonymous_array_int32_t_3 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_int32_t_3, element_flags_anonymous_array_int32_t_3); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(3)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_int32_t_3, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_int32_t_3)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_int32_t_3", type_ids_points)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_int32_t_3 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_points = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_points = 0x00000000; + bool common_points_ec {false}; + CommonStructMember common_points {TypeObjectUtils::build_common_struct_member(member_id_points, member_flags_points, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_points, common_points_ec))}; + if (!common_points_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure points member TypeIdentifier inconsistent."); + return; + } + MemberName name_points = "points"; + eprosima::fastcdr::optional member_ann_builtin_points; + ann_custom_numeric_array.reset(); + CompleteMemberDetail detail_points = TypeObjectUtils::build_complete_member_detail(name_points, member_ann_builtin_points, ann_custom_numeric_array); + CompleteStructMember member_points = TypeObjectUtils::build_complete_struct_member(common_points, detail_points); + TypeObjectUtils::add_complete_struct_member(member_seq_numeric_array, member_points); + } + CompleteStructType struct_type_numeric_array = TypeObjectUtils::build_complete_struct_type(struct_flags_numeric_array, header_numeric_array, member_seq_numeric_array); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_numeric_array, type_name_numeric_array.to_string(), type_ids_numeric_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "numeric_array already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp new file mode 100644 index 00000000000..05a27bf5b81 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file numeric_arrayTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register numeric_array related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_numeric_array_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp new file mode 100644 index 00000000000..20aad0b7c30 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp @@ -0,0 +1,676 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_UNION_STRUCT_HPP_ + +#include +#include +#include +#include +#include +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(UNION_STRUCT_SOURCE) +#define UNION_STRUCT_DllAPI __declspec( dllexport ) +#else +#define UNION_STRUCT_DllAPI __declspec( dllimport ) +#endif // UNION_STRUCT_SOURCE +#else +#define UNION_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define UNION_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the union MyUnion defined by the user in the IDL file. + * @ingroup union_struct + */ +class MyUnion +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport MyUnion() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~MyUnion() + { + if (member_destructor_) + { + member_destructor_(); + } + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object MyUnion that will be copied. + */ + eProsima_user_DllExport MyUnion( + const MyUnion& x) + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + octet_value_() = x.m_octet_value; + break; + + case 0x00000002: + long_value_() = x.m_long_value; + break; + + case 0x00000003: + string_value_() = x.m_string_value; + break; + + } + } + + /*! + * @brief Move constructor. + * @param x Reference to the object MyUnion that will be copied. + */ + eProsima_user_DllExport MyUnion( + MyUnion&& x) noexcept + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + octet_value_() = std::move(x.m_octet_value); + break; + + case 0x00000002: + long_value_() = std::move(x.m_long_value); + break; + + case 0x00000003: + string_value_() = std::move(x.m_string_value); + break; + + } + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object MyUnion that will be copied. + */ + eProsima_user_DllExport MyUnion& operator =( + const MyUnion& x) + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + octet_value_() = x.m_octet_value; + break; + + case 0x00000002: + long_value_() = x.m_long_value; + break; + + case 0x00000003: + string_value_() = x.m_string_value; + break; + + } + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object MyUnion that will be copied. + */ + eProsima_user_DllExport MyUnion& operator =( + MyUnion&& x) noexcept + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + octet_value_() = std::move(x.m_octet_value); + break; + + case 0x00000002: + long_value_() = std::move(x.m_long_value); + break; + + case 0x00000003: + string_value_() = std::move(x.m_string_value); + break; + + } + + return *this; + } + + /*! + * @brief Comparison operator. + * @param x MyUnion object to compare. + */ + eProsima_user_DllExport bool operator ==( + const MyUnion& x) const + { + bool ret_value {false}; + + if (m__d == x.m__d && + selected_member_ == x.selected_member_) + { + switch (selected_member_) + { + case 0x00000001: + ret_value = (m_octet_value == x.m_octet_value); + break; + + case 0x00000002: + ret_value = (m_long_value == x.m_long_value); + break; + + case 0x00000003: + ret_value = (m_string_value == x.m_string_value); + break; + + } + } + + return ret_value; + } + + /*! + * @brief Comparison operator. + * @param x MyUnion object to compare. + */ + eProsima_user_DllExport bool operator !=( + const MyUnion& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets the discriminator value. + * @param __d New value for the discriminator. + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the new value doesn't correspond to the selected union member. + */ + eProsima_user_DllExport void _d( + int32_t __d) + { + bool valid_discriminator = false; + + switch (__d) + { + case 1: + if (0x00000001 == selected_member_) + { + valid_discriminator = true; + } + break; + + case 2: + if (0x00000002 == selected_member_) + { + valid_discriminator = true; + } + break; + + case 3: + if (0x00000003 == selected_member_) + { + valid_discriminator = true; + } + break; + + } + + if (!valid_discriminator) + { + throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member"); + } + + m__d = __d; + } + + /*! + * @brief This function returns the value of the discriminator. + * @return Value of the discriminator + */ + eProsima_user_DllExport int32_t _d() const + { + return m__d; + } + + /*! + * @brief This function sets a value in member octet_value + * @param _octet_value New value for member octet_value + */ + eProsima_user_DllExport void octet_value( + uint8_t _octet_value) + { + octet_value_() = _octet_value; + m__d = 1; + } + + /*! + * @brief This function returns the value of member octet_value + * @return Value of member octet_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport uint8_t octet_value() const + { + if (0x00000001 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_octet_value; + } + + /*! + * @brief This function returns a reference to member octet_value + * @return Reference to member octet_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport uint8_t& octet_value() + { + if (0x00000001 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_octet_value; + } + + + /*! + * @brief This function sets a value in member long_value + * @param _long_value New value for member long_value + */ + eProsima_user_DllExport void long_value( + int32_t _long_value) + { + long_value_() = _long_value; + m__d = 2; + } + + /*! + * @brief This function returns the value of member long_value + * @return Value of member long_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport int32_t long_value() const + { + if (0x00000002 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_long_value; + } + + /*! + * @brief This function returns a reference to member long_value + * @return Reference to member long_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport int32_t& long_value() + { + if (0x00000002 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_long_value; + } + + + /*! + * @brief This function copies the value in member string_value + * @param _string_value New value to be copied in member string_value + */ + eProsima_user_DllExport void string_value( + const std::string& _string_value) + { + string_value_() = _string_value; + m__d = 3; + } + + /*! + * @brief This function moves the value in member string_value + * @param _string_value New value to be moved in member string_value + */ + eProsima_user_DllExport void string_value( + std::string&& _string_value) + { + string_value_() = _string_value; + m__d = 3; + } + + /*! + * @brief This function returns a constant reference to member string_value + * @return Constant reference to member string_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport const std::string& string_value() const + { + if (0x00000003 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_string_value; + } + + /*! + * @brief This function returns a reference to member string_value + * @return Reference to member string_value + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport std::string& string_value() + { + if (0x00000003 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_string_value; + } + + + void _default() + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x0FFFFFFFu; + } + + +private: + + uint8_t& octet_value_() + { + if (0x00000001 != selected_member_) + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x00000001; + member_destructor_ = nullptr; + m_octet_value = {0}; + ; + } + + return m_octet_value; + } + + int32_t& long_value_() + { + if (0x00000002 != selected_member_) + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x00000002; + member_destructor_ = nullptr; + m_long_value = {0}; + ; + } + + return m_long_value; + } + + std::string& string_value_() + { + if (0x00000003 != selected_member_) + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x00000003; + member_destructor_ = [&]() {m_string_value.~basic_string();}; + new(&m_string_value) std::string(); + ; + } + + return m_string_value; + } + + + int32_t m__d {0}; + + union + { + uint8_t m_octet_value; + int32_t m_long_value; + std::string m_string_value; + }; + + uint32_t selected_member_ {0x0FFFFFFFu}; + + std::function member_destructor_; +}; +/*! + * @brief This class represents the structure union_struct defined by the user in the IDL file. + * @ingroup union_struct + */ +class union_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport union_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~union_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object union_struct that will be copied. + */ + eProsima_user_DllExport union_struct( + const union_struct& x) + { + m_index = x.m_index; + + m_union_value = x.m_union_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object union_struct that will be copied. + */ + eProsima_user_DllExport union_struct( + union_struct&& x) noexcept + { + m_index = x.m_index; + m_union_value = std::move(x.m_union_value); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object union_struct that will be copied. + */ + eProsima_user_DllExport union_struct& operator =( + const union_struct& x) + { + + m_index = x.m_index; + + m_union_value = x.m_union_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object union_struct that will be copied. + */ + eProsima_user_DllExport union_struct& operator =( + union_struct&& x) noexcept + { + + m_index = x.m_index; + m_union_value = std::move(x.m_union_value); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x union_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const union_struct& x) const + { + return (m_index == x.m_index && + m_union_value == x.m_union_value); + } + + /*! + * @brief Comparison operator. + * @param x union_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const union_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member index + * @param _index New value for member index + */ + eProsima_user_DllExport void index( + uint32_t _index) + { + m_index = _index; + } + + /*! + * @brief This function returns the value of member index + * @return Value of member index + */ + eProsima_user_DllExport uint32_t index() const + { + return m_index; + } + + /*! + * @brief This function returns a reference to member index + * @return Reference to member index + */ + eProsima_user_DllExport uint32_t& index() + { + return m_index; + } + + + /*! + * @brief This function copies the value in member union_value + * @param _union_value New value to be copied in member union_value + */ + eProsima_user_DllExport void union_value( + const MyUnion& _union_value) + { + m_union_value = _union_value; + } + + /*! + * @brief This function moves the value in member union_value + * @param _union_value New value to be moved in member union_value + */ + eProsima_user_DllExport void union_value( + MyUnion&& _union_value) + { + m_union_value = std::move(_union_value); + } + + /*! + * @brief This function returns a constant reference to member union_value + * @return Constant reference to member union_value + */ + eProsima_user_DllExport const MyUnion& union_value() const + { + return m_union_value; + } + + /*! + * @brief This function returns a reference to member union_value + * @return Reference to member union_value + */ + eProsima_user_DllExport MyUnion& union_value() + { + return m_union_value; + } + + + +private: + + uint32_t m_index{0}; + MyUnion m_union_value; + +}; + +#endif // _FAST_DDS_GENERATED_UNION_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp new file mode 100644 index 00000000000..19fe3c1b448 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp @@ -0,0 +1,47 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ + +#include "union_struct.hpp" + +constexpr uint32_t union_struct_max_cdr_typesize {276UL}; +constexpr uint32_t union_struct_max_key_cdr_typesize {0UL}; + + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const union_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp new file mode 100644 index 00000000000..3472d9e6988 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp @@ -0,0 +1,277 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ + +#include "union_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const MyUnion& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), data._d(), + current_alignment); + + switch (data._d()) + { + case 1: + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.octet_value(), current_alignment); + break; + + case 2: + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.long_value(), current_alignment); + break; + + case 3: + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.string_value(), current_alignment); + break; + + default: + break; + } + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const MyUnion& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr << eprosima::fastcdr::MemberId(0) << data._d(); + + switch (data._d()) + { + case 1: + scdr << eprosima::fastcdr::MemberId(1) << data.octet_value(); + break; + + case 2: + scdr << eprosima::fastcdr::MemberId(2) << data.long_value(); + break; + + case 3: + scdr << eprosima::fastcdr::MemberId(3) << data.string_value(); + break; + + default: + break; + } + + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + MyUnion& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + if (0 == mid.id) + { + int32_t discriminator; + dcdr >> discriminator; + + switch (discriminator) + { + case 1: + { + uint8_t octet_value_value{0}; + data.octet_value(std::move(octet_value_value)); + data._d(discriminator); + break; + } + + case 2: + { + int32_t long_value_value{0}; + data.long_value(std::move(long_value_value)); + data._d(discriminator); + break; + } + + case 3: + { + std::string string_value_value; + data.string_value(std::move(string_value_value)); + data._d(discriminator); + break; + } + + default: + data._default(); + break; + } + } + else + { + switch (data._d()) + { + case 1: + dcdr >> data.octet_value(); + break; + + case 2: + dcdr >> data.long_value(); + break; + + case 3: + dcdr >> data.string_value(); + break; + + default: + break; + } + ret_value = false; + } + return ret_value; + }); +} + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const union_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.index(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.union_value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const union_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.index() + << eprosima::fastcdr::MemberId(1) << data.union_value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + union_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.index(); + break; + + case 1: + dcdr >> data.union_value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const union_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx new file mode 100644 index 00000000000..fb3bc458a64 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "union_structPubSubTypes.h" + +#include +#include + +#include "union_structCdrAux.hpp" +#include "union_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +union_structPubSubType::union_structPubSubType() +{ + setName("union_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(union_struct::getMaxCdrSerializedSize()); +#else + union_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = union_struct_max_key_cdr_typesize > 16 ? union_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +union_structPubSubType::~union_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool union_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + union_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool union_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + union_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function union_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* union_structPubSubType::createData() +{ + return reinterpret_cast(new union_struct()); +} + +void union_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool union_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + union_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + union_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || union_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void union_structPubSubType::register_type_object_representation() +{ + register_union_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "union_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h new file mode 100644 index 00000000000..310df478642 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "union_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated union_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type union_struct defined by the user in the IDL file. + * @ingroup union_struct + */ +class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef union_struct type; + + eProsima_user_DllExport union_structPubSubType(); + + eProsima_user_DllExport ~union_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..fd7ed407254 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx @@ -0,0 +1,291 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "union_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "union_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_MyUnion_type_identifier( + TypeIdentifierPair& type_ids_MyUnion) +{ + ReturnCode_t return_code_MyUnion {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyUnion", type_ids_MyUnion); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + { + UnionTypeFlag union_flags_MyUnion = TypeObjectUtils::build_union_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_MyUnion = "MyUnion"; + eprosima::fastcdr::optional type_ann_builtin_MyUnion; + eprosima::fastcdr::optional ann_custom_MyUnion; + CompleteTypeDetail detail_MyUnion = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyUnion, ann_custom_MyUnion, type_name_MyUnion.to_string()); + CompleteUnionHeader header_MyUnion = TypeObjectUtils::build_complete_union_header(detail_MyUnion); + UnionDiscriminatorFlag member_flags_MyUnion = TypeObjectUtils::build_union_discriminator_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false); + return_code_MyUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_MyUnion); + + if (return_code_MyUnion != eprosima::fastdds::dds::RETCODE_OK) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Union discriminator TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + CommonDiscriminatorMember common_MyUnion; + if (EK_COMPLETE == type_ids_MyUnion.type_identifier1()._d() || TK_NONE == type_ids_MyUnion.type_identifier2()._d()) + { + common_MyUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_MyUnion, type_ids_MyUnion.type_identifier1()); + } + else if (EK_COMPLETE == type_ids_MyUnion.type_identifier2()._d()) + { + common_MyUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_MyUnion, type_ids_MyUnion.type_identifier2()); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyUnion discriminator TypeIdentifier inconsistent."); + return; + } + type_ann_builtin_MyUnion.reset(); + ann_custom_MyUnion.reset(); + CompleteDiscriminatorMember discriminator_MyUnion = TypeObjectUtils::build_complete_discriminator_member(common_MyUnion, + type_ann_builtin_MyUnion, ann_custom_MyUnion); + CompleteUnionMemberSeq member_seq_MyUnion; + { + return_code_MyUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_byte", type_ids_MyUnion); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "octet_value Union member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + UnionMemberFlag member_flags_octet_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false); + UnionCaseLabelSeq label_seq_octet_value; + TypeObjectUtils::add_union_case_label(label_seq_octet_value, static_cast(1)); + MemberId member_id_octet_value = 0x00000001; + bool common_octet_value_ec {false}; + CommonUnionMember common_octet_value {TypeObjectUtils::build_common_union_member(member_id_octet_value, + member_flags_octet_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, + common_octet_value_ec), label_seq_octet_value)}; + if (!common_octet_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union octet_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_octet_value = "octet_value"; + eprosima::fastcdr::optional member_ann_builtin_octet_value; + ann_custom_MyUnion.reset(); + CompleteMemberDetail detail_octet_value = TypeObjectUtils::build_complete_member_detail(name_octet_value, member_ann_builtin_octet_value, ann_custom_MyUnion); + CompleteUnionMember member_octet_value = TypeObjectUtils::build_complete_union_member(common_octet_value, detail_octet_value); + TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_octet_value); + } + { + return_code_MyUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_MyUnion); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "long_value Union member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + UnionMemberFlag member_flags_long_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false); + UnionCaseLabelSeq label_seq_long_value; + TypeObjectUtils::add_union_case_label(label_seq_long_value, static_cast(2)); + MemberId member_id_long_value = 0x00000002; + bool common_long_value_ec {false}; + CommonUnionMember common_long_value {TypeObjectUtils::build_common_union_member(member_id_long_value, + member_flags_long_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, + common_long_value_ec), label_seq_long_value)}; + if (!common_long_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union long_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_long_value = "long_value"; + eprosima::fastcdr::optional member_ann_builtin_long_value; + ann_custom_MyUnion.reset(); + CompleteMemberDetail detail_long_value = TypeObjectUtils::build_complete_member_detail(name_long_value, member_ann_builtin_long_value, ann_custom_MyUnion); + CompleteUnionMember member_long_value = TypeObjectUtils::build_complete_union_member(common_long_value, detail_long_value); + TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_long_value); + } + { + return_code_MyUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_MyUnion); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_MyUnion)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + UnionMemberFlag member_flags_string_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false); + UnionCaseLabelSeq label_seq_string_value; + TypeObjectUtils::add_union_case_label(label_seq_string_value, static_cast(3)); + MemberId member_id_string_value = 0x00000003; + bool common_string_value_ec {false}; + CommonUnionMember common_string_value {TypeObjectUtils::build_common_union_member(member_id_string_value, + member_flags_string_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, + common_string_value_ec), label_seq_string_value)}; + if (!common_string_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union string_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_string_value = "string_value"; + eprosima::fastcdr::optional member_ann_builtin_string_value; + ann_custom_MyUnion.reset(); + CompleteMemberDetail detail_string_value = TypeObjectUtils::build_complete_member_detail(name_string_value, member_ann_builtin_string_value, ann_custom_MyUnion); + CompleteUnionMember member_string_value = TypeObjectUtils::build_complete_union_member(common_string_value, detail_string_value); + TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_string_value); + } + CompleteUnionType union_type_MyUnion = TypeObjectUtils::build_complete_union_type(union_flags_MyUnion, header_MyUnion, discriminator_MyUnion, + member_seq_MyUnion); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_union_type_object(union_type_MyUnion, type_name_MyUnion.to_string(), type_ids_MyUnion)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyUnion already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_union_struct_type_identifier( + TypeIdentifierPair& type_ids_union_struct) +{ + + ReturnCode_t return_code_union_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_union_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "union_struct", type_ids_union_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_union_struct) + { + StructTypeFlag struct_flags_union_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_union_struct = "union_struct"; + eprosima::fastcdr::optional type_ann_builtin_union_struct; + eprosima::fastcdr::optional ann_custom_union_struct; + CompleteTypeDetail detail_union_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_union_struct, ann_custom_union_struct, type_name_union_struct.to_string()); + CompleteStructHeader header_union_struct; + header_union_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_union_struct); + CompleteStructMemberSeq member_seq_union_struct; + { + TypeIdentifierPair type_ids_index; + ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; + return_code_index = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_index); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_index = 0x00000000; + bool common_index_ec {false}; + CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; + if (!common_index_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); + return; + } + MemberName name_index = "index"; + eprosima::fastcdr::optional member_ann_builtin_index; + ann_custom_union_struct.reset(); + CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_union_struct); + CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); + TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_index); + } + { + TypeIdentifierPair type_ids_union_value; + ReturnCode_t return_code_union_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_union_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyUnion", type_ids_union_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_union_value) + { + ::register_MyUnion_type_identifier(type_ids_union_value); + } + StructMemberFlag member_flags_union_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_union_value = 0x00000001; + bool common_union_value_ec {false}; + CommonStructMember common_union_value {TypeObjectUtils::build_common_struct_member(member_id_union_value, member_flags_union_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_union_value, common_union_value_ec))}; + if (!common_union_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure union_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_union_value = "union_value"; + eprosima::fastcdr::optional member_ann_builtin_union_value; + ann_custom_union_struct.reset(); + CompleteMemberDetail detail_union_value = TypeObjectUtils::build_complete_member_detail(name_union_value, member_ann_builtin_union_value, ann_custom_union_struct); + CompleteStructMember member_union_value = TypeObjectUtils::build_complete_struct_member(common_union_value, detail_union_value); + TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_union_value); + } + CompleteStructType struct_type_union_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_union_struct, header_union_struct, member_seq_union_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_union_struct, type_name_union_struct.to_string(), type_ids_union_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "union_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..6e1e1dbf58f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file union_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register MyUnion related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyUnion_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register union_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_union_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From fdd8c207464544fd20dc06e3dde4ea8f2b8b9123 Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 19 Jun 2024 17:11:53 +0200 Subject: [PATCH 12/52] Tests fixes - unbounded sequence & array length Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 36 +++++++++++++++--------- 1 file changed, 22 insertions(+), 14 deletions(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index 6fce8475c92..ff7b03aca2c 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -64,15 +64,16 @@ ReturnCode_t dyn_type_to_tree( for (const auto& member : members_by_name) { - ret = dyn_type_to_tree(member.second, member.first, node); + utilities::collections::TreeNode child; + ret = dyn_type_to_tree(member.second, member.first, child); if (ret != RETCODE_OK) { return ret; } - // Add each member with its name as a new node in a branch (recursion) - parent.add_branch(node); + // Add each member with its name as a new child in a branch (recursion) + parent.add_branch(child); } node = parent; @@ -92,7 +93,7 @@ ReturnCode_t dyn_type_to_tree( } std::string internal_str; - ret = dyn_type_to_str(internal_type, internal_str); + ret = dyn_type_to_str(type, internal_str); if (ret != RETCODE_OK) { @@ -303,7 +304,7 @@ ReturnCode_t array_kind_to_str( for (const auto& bound : bounds) { array_str += "["; - array_str += bound; + array_str += std::to_string(bound); array_str += "]"; } @@ -349,13 +350,11 @@ ReturnCode_t sequence_kind_to_str( for (const auto& bound : bounds) { - if (bound == static_cast(LENGTH_UNLIMITED)) - { - sequence_str += ", unbounded"; - } - else + const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); + + if (bound != UNBOUNDED) { - sequence_str += ", " + bound; + sequence_str += ", " + std::to_string(bound); } } @@ -527,7 +526,9 @@ ReturnCode_t dyn_type_tree_to_idl( break; } default: + { continue; + } } if (ret != RETCODE_OK) @@ -722,9 +723,16 @@ ReturnCode_t node_to_str( if (node.info.dynamic_type->get_kind() == TK_ARRAY) { - auto dim_pos = node.info.type_kind_name.find("["); - auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); - auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); + const auto dim_pos = node.info.type_kind_name.find("["); + + if (dim_pos == std::string::npos) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Array type name is not well formed."); + return RETCODE_BAD_PARAMETER; + } + + const auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); + const auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); node_str += kind_name_str + " " + node.info.member_name + dim_str; } From f06af4d284d0f7825ec66228c5fb77bca1496766 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 10:52:26 +0200 Subject: [PATCH 13/52] Tests fixes - TK_ENUM Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index ff7b03aca2c..ced4ca58138 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -595,28 +595,25 @@ ReturnCode_t enum_to_str( ReturnCode_t ret = RETCODE_OK; - std::map members; - ret = node.info.dynamic_type->get_all_members(members); + enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; - if (ret != RETCODE_OK) + for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) { - return ret; - } + traits::ref_type member; + ret = node.info.dynamic_type->get_member_by_index(member, index); - enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; - bool first_iter = true; + if (ret != RETCODE_OK) + { + return ret; + } - for (const auto& member : members) - { - if (!first_iter) + if (index != 0) { enum_str += ",\n"; enum_str += TAB_SEPARATOR; } - first_iter = false; - - enum_str += member.second->get_name(); + enum_str += member->get_name().to_string(); } // Close definition From 489de2cd5025519792325b66b974e81815817d68 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 11:10:31 +0200 Subject: [PATCH 14/52] Tests fixes - TK_UNION Signed-off-by: tempate --- src/cpp/fastdds/xtypes/dyn_type_tree.ipp | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp index ced4ca58138..c5897572dd3 100644 --- a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/dyn_type_tree.ipp @@ -653,18 +653,13 @@ ReturnCode_t union_to_str( union_str = "union " + node.info.type_kind_name + " switch (" + discriminant_type_str + ")" + TYPE_OPENING; - std::map members; - ret = node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available - - if (ret != RETCODE_OK) + for (std::uint32_t index = 1; index < node.info.dynamic_type->get_member_count(); index++) { - return ret; - } + traits::ref_type member; + ret = node.info.dynamic_type->get_member_by_index(member, index); - for (const auto& member : members) - { MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member.second->get_descriptor(member_descriptor); + ret = member->get_descriptor(member_descriptor); if (ret != RETCODE_OK) { @@ -702,7 +697,7 @@ ReturnCode_t union_to_str( union_str += TAB_SEPARATOR; union_str += TAB_SEPARATOR; union_str += member_str + " "; - union_str += member.second->get_name(); + union_str += member->get_name().to_string(); union_str += ";\n"; } From 33ae94f55805818c6ff42ce48901a244ad307943 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 12:11:16 +0200 Subject: [PATCH 15/52] Update versions.md Signed-off-by: tempate --- versions.md | 1 + 1 file changed, 1 insertion(+) diff --git a/versions.md b/versions.md index 0e089ecde11..f9a03651782 100644 --- a/versions.md +++ b/versions.md @@ -83,6 +83,7 @@ Forthcoming * Refactor in XML Parser to return DynamicTypeBuilder instead of DynamicType * Setting vendor_id in the received CacheChange_t for Data and DataFrag. * Added new DynamicData to JSON serializer (`json_serialize`). +* Added new DynamicType to IDL serializer (`idl_serialize`). Version 2.14.0 -------------- From 7e7ad25f46dfe1e15bef2b2c449f087c274e2398 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 12:16:45 +0200 Subject: [PATCH 16/52] Move dyn_type_tree to type_conversion Signed-off-by: tempate --- src/cpp/fastdds/xtypes/{ => type_conversion}/dyn_type_tree.hpp | 0 src/cpp/fastdds/xtypes/{ => type_conversion}/dyn_type_tree.ipp | 0 src/cpp/fastdds/xtypes/utils.cpp | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) rename src/cpp/fastdds/xtypes/{ => type_conversion}/dyn_type_tree.hpp (100%) rename src/cpp/fastdds/xtypes/{ => type_conversion}/dyn_type_tree.ipp (100%) diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp similarity index 100% rename from src/cpp/fastdds/xtypes/dyn_type_tree.hpp rename to src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp diff --git a/src/cpp/fastdds/xtypes/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp similarity index 100% rename from src/cpp/fastdds/xtypes/dyn_type_tree.ipp rename to src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index f42469b2d96..19c04a3ad28 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -40,7 +40,7 @@ #include "dynamic_types/DynamicDataImpl.hpp" #include "serializers/json/dynamic_data_json.hpp" -#include "dyn_type_tree.hpp" +#include "type_conversion/dyn_type_tree.hpp" #include "utils/collections/Tree.hpp" From f2cfee8bf2cc51d7a2e3c3d87d8bd5e91b0bcdc5 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 15:15:06 +0200 Subject: [PATCH 17/52] Tests - Tree Signed-off-by: tempate --- test/unittest/utils/CMakeLists.txt | 8 ++ test/unittest/utils/TreeTests.cpp | 193 +++++++++++++++++++++++++++++ 2 files changed, 201 insertions(+) create mode 100644 test/unittest/utils/TreeTests.cpp diff --git a/test/unittest/utils/CMakeLists.txt b/test/unittest/utils/CMakeLists.txt index 881b79ded67..9d3110fdcfb 100644 --- a/test/unittest/utils/CMakeLists.txt +++ b/test/unittest/utils/CMakeLists.txt @@ -65,6 +65,9 @@ set(SYSTEMINFOTESTS_SOURCE ${PROJECT_SOURCE_DIR}/src/cpp/utils/IPLocator.cpp ${PROJECT_SOURCE_DIR}/src/cpp/utils/SystemInfo.cpp) +set(TREETESTS_SOURCE + TreeTests.cpp) + include_directories(mock/) add_executable(StringMatchingTests ${STRINGMATCHINGTESTS_SOURCE}) @@ -167,6 +170,11 @@ target_include_directories(SharedMutexTests PRIVATE ${PROJECT_SOURCE_DIR}/src/cp target_link_libraries(SharedMutexTests PUBLIC GTest::gtest) gtest_discover_tests(SharedMutexTests) +add_executable(TreeTests ${TREETESTS_SOURCE}) +target_include_directories(TreeTests PRIVATE ${PROJECT_SOURCE_DIR}/src/cpp) +target_link_libraries(TreeTests PUBLIC GTest::gtest) +gtest_discover_tests(TreeTests) + ############################################################################### # Necessary files ############################################################################### diff --git a/test/unittest/utils/TreeTests.cpp b/test/unittest/utils/TreeTests.cpp new file mode 100644 index 00000000000..2f70625a763 --- /dev/null +++ b/test/unittest/utils/TreeTests.cpp @@ -0,0 +1,193 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include + +#include + +#include + +using namespace eprosima; + + +struct TreeNodeTestType +{ + TreeNodeTestType( + const std::string& name) + : name(name) + { + } + + const std::string name; +}; + +/** + * @brief Test that a tree can support one shallow branch. + * + * 0 + * │ + * ▼ + * 1 + */ +TEST(TreeTests, one_shallow_branch) +{ + constexpr auto NODE_COUNT = 2; + + std::vector nodes; + std::vector> trees; + + // Create the nodes and the trees + for (int i = 0; i < NODE_COUNT; i++) + { + nodes.emplace_back(std::to_string(i)); + trees.emplace_back(nodes[i]); + } + + // Build the tree + auto& root = trees[0]; + + root.add_branch(trees[1]); + + // Verify the depth + const auto tree_depth = root.depth(); + ASSERT_EQ(tree_depth, 1); + + // Verify the nodes are correct + const auto tree_nodes = root.all_nodes(); + ASSERT_EQ(tree_nodes.size(), NODE_COUNT - 1); + + // Verify the branch count + const auto tree_branches = root.branches(); + ASSERT_EQ(tree_branches.size(), 1); + + // Verify that the branch is a leaf + ASSERT_TRUE(tree_branches.front().leaf()); +} + +/** + * @brief Test that a tree can support one deep branch. + * + * 0 + * │ + * ▼ + * 1 + * │ + * ▼ + * 2 + * │ + * ▼ + * 3 + * │ + * ▼ + * 4 + * │ + * ▼ + * 5 + */ +TEST(TreeTests, one_deep_branch) +{ + constexpr auto NODE_COUNT = 6; + + std::vector nodes; + std::vector> trees; + + // Create the nodes and the trees + for (int i = 0; i < NODE_COUNT; i++) + { + nodes.emplace_back(std::to_string(i)); + trees.emplace_back(nodes[i]); + } + + // Build the tree + for (int i = NODE_COUNT - 1; i >= 1; i--) + { + trees[i-1].add_branch(trees[i]); + } + + const auto& root = trees[0]; + + // Verify the depth + const auto tree_depth = root.depth(); + ASSERT_EQ(tree_depth, NODE_COUNT - 1); + + // Verify the nodes are correct + const auto tree_nodes = root.all_nodes(); + ASSERT_EQ(tree_nodes.size(), NODE_COUNT - 1); + + // Verify the branch count + const auto tree_branches = root.branches(); + ASSERT_EQ(tree_branches.size(), 1); + + // Verify that the branch is not a leaf + ASSERT_FALSE(tree_branches.front().leaf()); +} + +/** + * @brief Test that a tree can support many shallow branches. + * + * ┌───┬───0───┬───┐ + * │ │ │ │ │ + * ▼ ▼ ▼ ▼ ▼ + * 1 2 3 4 5 + */ +TEST(TreeTests, many_shallow_branches) +{ + constexpr auto NODE_COUNT = 6; + + std::vector nodes; + std::vector> trees; + + // Create the nodes and the trees + for (int i = 0; i < NODE_COUNT; i++) + { + nodes.emplace_back(std::to_string(i)); + trees.emplace_back(nodes[i]); + } + + // Build the tree + auto& root = trees[0]; + + for (int i = 1; i < NODE_COUNT; i++) + { + root.add_branch(nodes[i]); + } + + // Verify the depth + const auto tree_depth = root.depth(); + ASSERT_EQ(tree_depth, 1); + + // Verify the node count + const auto tree_nodes = root.all_nodes(); + ASSERT_EQ(tree_nodes.size(), NODE_COUNT - 1); + + // Verify the branch count + const auto tree_branches = root.branches(); + ASSERT_EQ(tree_branches.size(), NODE_COUNT - 1); + + // Verify that every branch is a leaf + for (const auto& branch : tree_branches) + { + ASSERT_TRUE(branch.leaf()); + } +} + + +int main( + int argc, + char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} From 9e18246237e91b13a57ffb138281863b959e4c28 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 15:16:45 +0200 Subject: [PATCH 18/52] Tests fixes - Tree depth Signed-off-by: tempate --- src/cpp/utils/collections/impl/Tree.ipp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/cpp/utils/collections/impl/Tree.ipp b/src/cpp/utils/collections/impl/Tree.ipp index e0311be842f..fbc69d4fe58 100644 --- a/src/cpp/utils/collections/impl/Tree.ipp +++ b/src/cpp/utils/collections/impl/Tree.ipp @@ -20,6 +20,9 @@ #ifndef SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ #define SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ +#include + + namespace eprosima { namespace utilities { namespace collections { @@ -92,13 +95,15 @@ bool TreeNode::leaf() const noexcept template unsigned int TreeNode::depth() const noexcept { - unsigned int max_value = 0; - for (const auto& b : branches_) + unsigned int max_child_depth = 0; + + for (const auto& branch : branches_) { - auto child_value = b.depth(); - max_value = MAX(max_value, child_value); + const auto child_depth = branch.depth() + 1; + max_child_depth = std::max(max_child_depth, child_depth); } - return max_value; + + return max_child_depth; } template From 7ab683c053b13dce31491fc87dd94a59648df7f1 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 20 Jun 2024 15:20:46 +0200 Subject: [PATCH 19/52] Rename Tree to TreeNode Signed-off-by: tempate --- .../fastdds/xtypes/type_conversion/dyn_type_tree.hpp | 2 +- src/cpp/fastdds/xtypes/utils.cpp | 2 +- src/cpp/utils/collections/{Tree.hpp => TreeNode.hpp} | 4 ++-- .../utils/collections/impl/{Tree.ipp => TreeNode.ipp} | 2 +- test/unittest/utils/CMakeLists.txt | 10 +++++----- .../utils/{TreeTests.cpp => TreeNodeTests.cpp} | 8 ++++---- 6 files changed, 14 insertions(+), 14 deletions(-) rename src/cpp/utils/collections/{Tree.hpp => TreeNode.hpp} (97%) rename src/cpp/utils/collections/impl/{Tree.ipp => TreeNode.ipp} (99%) rename test/unittest/utils/{TreeTests.cpp => TreeNodeTests.cpp} (96%) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index 2a212cce494..4faa779d7ec 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -27,7 +27,7 @@ #include #include -#include "utils/collections/Tree.hpp" +#include "utils/collections/TreeNode.hpp" namespace eprosima { namespace fastdds { diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 19c04a3ad28..ad1128a4354 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -42,7 +42,7 @@ #include "serializers/json/dynamic_data_json.hpp" #include "type_conversion/dyn_type_tree.hpp" -#include "utils/collections/Tree.hpp" +#include "utils/collections/TreeNode.hpp" namespace eprosima { namespace fastdds { diff --git a/src/cpp/utils/collections/Tree.hpp b/src/cpp/utils/collections/TreeNode.hpp similarity index 97% rename from src/cpp/utils/collections/Tree.hpp rename to src/cpp/utils/collections/TreeNode.hpp index bb9f161b9e0..25b9830ebf6 100644 --- a/src/cpp/utils/collections/Tree.hpp +++ b/src/cpp/utils/collections/TreeNode.hpp @@ -13,7 +13,7 @@ // limitations under the License. /** - * @file Tree.hpp + * @file TreeNode.hpp * */ @@ -84,6 +84,6 @@ class TreeNode : public Node } /* namespace eprosima */ // Include implementation template file -#include "impl/Tree.ipp" +#include "impl/TreeNode.ipp" #endif /* FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ */ diff --git a/src/cpp/utils/collections/impl/Tree.ipp b/src/cpp/utils/collections/impl/TreeNode.ipp similarity index 99% rename from src/cpp/utils/collections/impl/Tree.ipp rename to src/cpp/utils/collections/impl/TreeNode.ipp index fbc69d4fe58..f22d7a1408d 100644 --- a/src/cpp/utils/collections/impl/Tree.ipp +++ b/src/cpp/utils/collections/impl/TreeNode.ipp @@ -13,7 +13,7 @@ // limitations under the License. /** - * @file Tree.ipp + * @file TreeNode.ipp * */ diff --git a/test/unittest/utils/CMakeLists.txt b/test/unittest/utils/CMakeLists.txt index 9d3110fdcfb..3c8da0c6c10 100644 --- a/test/unittest/utils/CMakeLists.txt +++ b/test/unittest/utils/CMakeLists.txt @@ -66,7 +66,7 @@ set(SYSTEMINFOTESTS_SOURCE ${PROJECT_SOURCE_DIR}/src/cpp/utils/SystemInfo.cpp) set(TREETESTS_SOURCE - TreeTests.cpp) + TreeNodeTests.cpp) include_directories(mock/) @@ -170,10 +170,10 @@ target_include_directories(SharedMutexTests PRIVATE ${PROJECT_SOURCE_DIR}/src/cp target_link_libraries(SharedMutexTests PUBLIC GTest::gtest) gtest_discover_tests(SharedMutexTests) -add_executable(TreeTests ${TREETESTS_SOURCE}) -target_include_directories(TreeTests PRIVATE ${PROJECT_SOURCE_DIR}/src/cpp) -target_link_libraries(TreeTests PUBLIC GTest::gtest) -gtest_discover_tests(TreeTests) +add_executable(TreeNodeTests ${TREETESTS_SOURCE}) +target_include_directories(TreeNodeTests PRIVATE ${PROJECT_SOURCE_DIR}/src/cpp) +target_link_libraries(TreeNodeTests PUBLIC GTest::gtest) +gtest_discover_tests(TreeNodeTests) ############################################################################### # Necessary files diff --git a/test/unittest/utils/TreeTests.cpp b/test/unittest/utils/TreeNodeTests.cpp similarity index 96% rename from test/unittest/utils/TreeTests.cpp rename to test/unittest/utils/TreeNodeTests.cpp index 2f70625a763..3a820286958 100644 --- a/test/unittest/utils/TreeTests.cpp +++ b/test/unittest/utils/TreeNodeTests.cpp @@ -17,7 +17,7 @@ #include -#include +#include using namespace eprosima; @@ -41,7 +41,7 @@ struct TreeNodeTestType * ▼ * 1 */ -TEST(TreeTests, one_shallow_branch) +TEST(TreeNodeTests, one_shallow_branch) { constexpr auto NODE_COUNT = 2; @@ -96,7 +96,7 @@ TEST(TreeTests, one_shallow_branch) * ▼ * 5 */ -TEST(TreeTests, one_deep_branch) +TEST(TreeNodeTests, one_deep_branch) { constexpr auto NODE_COUNT = 6; @@ -142,7 +142,7 @@ TEST(TreeTests, one_deep_branch) * ▼ ▼ ▼ ▼ ▼ * 1 2 3 4 5 */ -TEST(TreeTests, many_shallow_branches) +TEST(TreeNodeTests, many_shallow_branches) { constexpr auto NODE_COUNT = 6; From 00f95e4657b0f49a5e4d206799554609a6da44ab Mon Sep 17 00:00:00 2001 From: tempate Date: Fri, 21 Jun 2024 10:15:35 +0200 Subject: [PATCH 20/52] Tests - Refactor Dynamic Types to IDL Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 59 +++++++- .../type_conversion/DynTypeToIdlTests.cpp | 86 ----------- .../DynamicTypeSerializationTests.cpp | 106 +++++++++++++ .../type_conversion/types/all_types.hpp | 141 +++++++----------- 4 files changed, 207 insertions(+), 185 deletions(-) delete mode 100644 test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp create mode 100644 test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index 4c4549f6dd6..da149c44bcf 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -12,37 +12,80 @@ # See the License for the specific language governing permissions and # limitations under the License. +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/hello_world.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/hello_world.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/char_sequence.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/char_sequence.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_struct.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_array_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_array_struct.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/float_bounded_sequence.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/float_bounded_sequence.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/arrays_and_sequences.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/arrays_and_sequences.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/complex_nested_arrays.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/complex_nested_arrays.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/enum_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/enum_struct.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/union_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/union_struct.idl + COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl + COPYONLY) + set(RESOURCEDYNTYPETOIDLTESTS_SOURCE - DynTypeToIdlTests.cpp + DynamicTypeSerializationTests.cpp ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/xtypes/utils.cpp) file(GLOB DATATYPE_SOURCES_CPP "types/type_objects/**/*.cpp") file(GLOB DATATYPE_SOURCES_CXX "types/type_objects/**/*.cxx") -file(GLOB DATATYPE_SOURCES_IDL "types/idls/*.idl") set( DATATYPE_SOURCES ${DATATYPE_SOURCES_CPP} ${DATATYPE_SOURCES_CXX} - ${DATATYPE_SOURCES_IDL} ) if(WIN32) add_definitions(-D_WIN32_WINNT=0x0601) endif() -add_executable(DynTypeToIdlTests ${RESOURCEDYNTYPETOIDLTESTS_SOURCE} ${DATATYPE_SOURCES}) -target_compile_definitions(DynTypeToIdlTests PRIVATE +add_executable(DynamicTypeSerializationTests ${RESOURCEDYNTYPETOIDLTESTS_SOURCE} ${DATATYPE_SOURCES}) +target_compile_definitions(DynamicTypeSerializationTests PRIVATE $<$>,$>:__DEBUG> $<$:__INTERNALDEBUG> # Internal debug activated. ) -target_include_directories(DynTypeToIdlTests PRIVATE +target_include_directories(DynamicTypeSerializationTests PRIVATE ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include ${PROJECT_SOURCE_DIR}/src/cpp ) -target_link_libraries(DynTypeToIdlTests +target_link_libraries(DynamicTypeSerializationTests fastcdr fastdds GTest::gtest ${CMAKE_DL_LIBS}) -gtest_discover_tests(DynTypeToIdlTests SOURCES ${TYPEOBJECTUTILSTESTS_SOURCE}) +gtest_discover_tests(DynamicTypeSerializationTests SOURCES ${TYPEOBJECTUTILSTESTS_SOURCE}) diff --git a/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp b/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp deleted file mode 100644 index 15eb1ba9e90..00000000000 --- a/test/unittest/dds/xtypes/type_conversion/DynTypeToIdlTests.cpp +++ /dev/null @@ -1,86 +0,0 @@ -// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include -#include -#include - -#include - -#include -#include -#include - -#include "types/all_types.hpp" - -using namespace eprosima; - -class DynTypeToIdlTests : public ::testing::TestWithParam -{ -}; - -/** - * Verify that the IDL serialization of a DynamicType matches the IDL file that defined the type. - * - * CASES: - * - Verify that the IDL file was opened successfully. - * - Verify that the IDL serialization finished successfully. - * - Verify that the two IDLs match. - */ -TEST_P(DynTypeToIdlTests, msg_schema_generation) -{ - const test::SupportedType type = GetParam(); - - // Read the IDL file as a string - const std::string full_path{"/home/daniel/Documents/eprosima/dynamic_type_idl/src/fastdds/test/unittest/dds/xtypes/type_conversion/types/idls/"}; - const auto file_name = full_path + to_string(type) + ".idl"; - - std::ifstream file(file_name); - - ASSERT_TRUE(file.is_open()); - - const std::string idl_file{std::istreambuf_iterator(file), std::istreambuf_iterator()}; - - // Get Dynamic type - const fastdds::dds::DynamicType::_ref_type dyn_type = test::get_dynamic_type(type); - - // Serialize DynamicType to IDL - std::string idl_serialization; - ASSERT_EQ(fastdds::dds::idl_serialize(dyn_type, idl_serialization), fastdds::dds::RETCODE_OK); - - // Compare IDLs - ASSERT_EQ(idl_file, idl_serialization); -} - -INSTANTIATE_TEST_SUITE_P(DynTypeToIdlTests, DynTypeToIdlTests, ::testing::Values( - test::SupportedType::hello_world, - test::SupportedType::numeric_array, - test::SupportedType::char_sequence, - test::SupportedType::basic_struct, - test::SupportedType::basic_array_struct, - test::SupportedType::float_bounded_sequence, - test::SupportedType::arrays_and_sequences, - test::SupportedType::complex_nested_arrays, - test::SupportedType::enum_struct, - test::SupportedType::union_struct, - test::SupportedType::map_struct - )); - -int main( - int argc, - char** argv) -{ - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp b/test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp new file mode 100644 index 00000000000..f46225a3fbc --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp @@ -0,0 +1,106 @@ +// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "types/all_types.hpp" + +using namespace eprosima; +using namespace eprosima::fastdds::dds; + + +class DynamicTypeSerializationTests : public ::testing::TestWithParam +{ +public: + + void SetUp() + { + test::register_dynamic_types(); + } + +protected: + + void get_dynamic_type( + const std::string& type_name, + DynamicType::_ref_type& dyn_type) + { + // Find TypeObjects for the type + xtypes::TypeObjectPair type_objs; + ASSERT_EQ(DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects( + type_name, type_objs), + fastdds::dds::RETCODE_OK); + + // Create DynamicType from TypeObject + dyn_type = DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object( + type_objs.complete_type_object)->build(); + } +}; + +/** + * Verify that the IDL serialization of a DynamicType generated with Fast-DDS Gen matches its IDL file. + * + * CASES: + * - Verify that the IDL file was opened successfully. + * - Verify that the IDL serialization finished successfully. + * - Verify that the two IDLs match. + */ +TEST_P(DynamicTypeSerializationTests, to_idl) +{ + const std::string type = GetParam(); + + // Read the IDL file as a string + const auto file_name = std::string("types/idls/") + type + ".idl"; + + std::ifstream file(file_name); + ASSERT_TRUE(file.is_open()); + + const std::string idl_file{std::istreambuf_iterator(file), std::istreambuf_iterator()}; + + // Get Dynamic type + DynamicType::_ref_type dyn_type; + get_dynamic_type(type, dyn_type); + + // Serialize DynamicType to IDL + std::string idl_serialization; + ASSERT_EQ(idl_serialize(dyn_type, idl_serialization), RETCODE_OK); + + // Compare IDLs + ASSERT_EQ(idl_file, idl_serialization); +} + +INSTANTIATE_TEST_SUITE_P( + DynamicTypeSerializationTests, + DynamicTypeSerializationTests, + ::testing::ValuesIn(test::supported_types) +); + +int main( + int argc, + char** argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index 677f1206728..66a6c2a8f67 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -22,15 +22,9 @@ * for TYPE in hello_world numeric_array char_sequence basic_struct basic_array_struct float_bounded_sequence arrays_and_sequences complex_nested_arrays; do ${FASTDDSGEN_WS}/scripts/fastddsgen -replace -d ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/type_objects/ -typeobject -cs ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/idls/${TYPE}.idl; done */ -#pragma once +#include -#include -#include #include -#include -#include -#include -#include #include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" #include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" @@ -68,107 +62,72 @@ namespace test { -enum SupportedType -{ - hello_world, - numeric_array, - char_sequence, - basic_struct, - basic_array_struct, - float_bounded_sequence, - arrays_and_sequences, - complex_nested_arrays, - enum_struct, - union_struct, // NOTE: default case currently not supported in dynamic types - map_struct +namespace SupportedTypes { + +const std::string HELLO_WORLD{"hello_world"}; +const std::string NUMERIC_ARRAY{"numeric_array"}; +const std::string CHAR_SEQUENCE{"char_sequence"}; +const std::string BASIC_STRUCT{"basic_struct"}; +const std::string BASIC_ARRAY_STRUCT{"basic_array_struct"}; +const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; +const std::string ARRAYS_AND_SEQUENCES{"arrays_and_sequences"}; +const std::string COMPLEX_NESTED_ARRAYS{"complex_nested_arrays"}; +const std::string ENUM_STRUCT{"enum_struct"}; +const std::string UNION_STRUCT{"union_struct"}; +const std::string MAP_STRUCT{"map_struct"}; + +} // namespace SupportedTypes + +const std::vector supported_types = { + SupportedTypes::HELLO_WORLD, + SupportedTypes::NUMERIC_ARRAY, + SupportedTypes::CHAR_SEQUENCE, + SupportedTypes::BASIC_STRUCT, + SupportedTypes::BASIC_ARRAY_STRUCT, + SupportedTypes::FLOAT_BOUNDED_SEQUENCE, + SupportedTypes::ARRAYS_AND_SEQUENCES, + SupportedTypes::COMPLEX_NESTED_ARRAYS, + SupportedTypes::ENUM_STRUCT, + SupportedTypes::UNION_STRUCT, + SupportedTypes::MAP_STRUCT }; -std::string to_string(const SupportedType& type) +void register_dynamic_types() { - switch (type) - { - case SupportedType::hello_world: - return "hello_world"; - case SupportedType::numeric_array: - return "numeric_array"; - case SupportedType::char_sequence: - return "char_sequence"; - case SupportedType::basic_struct: - return "basic_struct"; - case SupportedType::basic_array_struct: - return "basic_array_struct"; - case SupportedType::float_bounded_sequence: - return "float_bounded_sequence"; - case SupportedType::arrays_and_sequences: - return "arrays_and_sequences"; - case SupportedType::complex_nested_arrays: - return "complex_nested_arrays"; - case SupportedType::enum_struct: - return "enum_struct"; - case SupportedType::union_struct: - return "union_struct"; - case SupportedType::map_struct: - return "map_struct"; - default: - return "invalid"; - } -} + using namespace eprosima::fastdds::dds; + TypeSupport type_hello_world(new hello_worldPubSubType()); + type_hello_world->register_type_object_representation(); -eprosima::fastdds::dds::DynamicType::_ref_type get_dynamic_type( // traits::ref_type - SupportedType dyn_type) -{ - // Register the type - eprosima::fastdds::dds::TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); - type_arrays_and_sequences->register_type_object_representation(); + TypeSupport type_numeric_array(new numeric_arrayPubSubType()); + type_numeric_array->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); - type_basic_array_struct->register_type_object_representation(); + TypeSupport type_char_sequence(new char_sequencePubSubType()); + type_char_sequence->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_basic_struct(new basic_structPubSubType()); + TypeSupport type_basic_struct(new basic_structPubSubType()); type_basic_struct->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); - type_complex_nested_arrays->register_type_object_representation(); - - eprosima::fastdds::dds::TypeSupport type_char_sequence(new char_sequencePubSubType()); - type_char_sequence->register_type_object_representation(); - - eprosima::fastdds::dds::TypeSupport type_enum_struct(new enum_structPubSubType()); - type_enum_struct->register_type_object_representation(); + TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); + type_basic_array_struct->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); + TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); type_float_bounded_sequence->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_hello_world(new hello_worldPubSubType()); - type_hello_world->register_type_object_representation(); - - eprosima::fastdds::dds::TypeSupport type_map_struct(new map_structPubSubType()); - type_map_struct->register_type_object_representation(); + TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); + type_arrays_and_sequences->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_numeric_array(new numeric_arrayPubSubType()); - type_numeric_array->register_type_object_representation(); + TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); + type_complex_nested_arrays->register_type_object_representation(); + TypeSupport type_enum_struct(new enum_structPubSubType()); + type_enum_struct->register_type_object_representation(); - eprosima::fastdds::dds::TypeSupport type_union_struct(new union_structPubSubType()); + TypeSupport type_union_struct(new union_structPubSubType()); type_union_struct->register_type_object_representation(); - auto type_name = to_string(dyn_type); - - eprosima::fastdds::dds::xtypes::TypeObjectPair type_objs; - if (eprosima::fastdds::dds::RETCODE_OK == eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects( - type_name, - type_objs)) - { - return eprosima::fastdds::dds::DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object(type_objs.complete_type_object)->build(); - } - - else - { - // throw eprosima::utils::InconsistencyException("No Type Object"); - } - - return nullptr; + TypeSupport type_map_struct(new map_structPubSubType()); + type_map_struct->register_type_object_representation(); } } /* namespace test */ From 7f85c7e83d51765c439a495c8759f66eecb36181 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 10:10:49 +0200 Subject: [PATCH 21/52] Support TK_BITSET Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 20 +++ .../xtypes/type_conversion/dyn_type_tree.ipp | 137 +++++++++++++++++- 2 files changed, 156 insertions(+), 1 deletion(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index 4faa779d7ec..ca80f473daa 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -186,6 +186,16 @@ ReturnCode_t union_to_str( const utilities::collections::TreeNode& node, std::string& union_str) noexcept; +/** + * @brief Converts a tree with a \c TK_BITSET root to an IDL string. + * + * @param node The root node of the tree. + * @param union_str The string representation of the tree. + */ +ReturnCode_t bitset_to_str( + const utilities::collections::TreeNode& node, + std::string& bitset_str) noexcept; + /** * @brief Converts a simple tree to an IDL string. * @@ -196,6 +206,16 @@ ReturnCode_t node_to_str( const utilities::collections::TreeNode& node, std::string& node_str) noexcept; +/** + * @brief Finds the default type kind for a variable with a given size. + * + * @param size The size of the variable. + * @param default_type The default type kind. + */ +ReturnCode_t get_default_type_kind( + const std::uint32_t size, + TypeKind& default_type) noexcept; + } // dds } // fastdds } // eprosima diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index c5897572dd3..c0f3026e54b 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -244,11 +244,11 @@ ReturnCode_t dyn_type_to_str( case TK_STRUCTURE: case TK_ENUM: case TK_UNION: + case TK_BITSET: { type_str = dyn_type->get_name().to_string(); break; } - case TK_BITSET: case TK_BITMASK: case TK_NONE: case TK_ALIAS: @@ -525,6 +525,11 @@ ReturnCode_t dyn_type_tree_to_idl( ret = union_to_str(node, kind_str); break; } + case TK_BITSET: + { + ret = bitset_to_str(node, kind_str); + break; + } default: { continue; @@ -707,6 +712,103 @@ ReturnCode_t union_to_str( return ret; } +ReturnCode_t bitset_to_str( + const utilities::collections::TreeNode& node, + std::string& bitset_str) noexcept +{ + if (node.info.dynamic_type->get_kind() != TK_BITSET) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitset."); + return RETCODE_BAD_PARAMETER; + } + + ReturnCode_t ret = RETCODE_OK; + + bitset_str = "bitset " + node.info.type_kind_name + TYPE_OPENING; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Find the bits that each bitfield occupies + const auto bits = type_descriptor->bound(); + + std::uint32_t bits_set = 0; + + for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) + { + traits::ref_type member; + ret = node.info.dynamic_type->get_member_by_index(member, index); + + if (ret != RETCODE_OK) + { + return ret; + } + + // The id of the member is the position in the bitset + const auto id = member->get_id(); + + if (id > bits_set) + { + // If the id is higher than the bits set, there must have been an empty bitfield (i.e. a gap) + const auto bits = id - bits_set; + bits_set += bits; + + bitset_str += TAB_SEPARATOR; + bitset_str += "bitfield<"; + bitset_str += std::to_string(bits); + bitset_str += ">;\n"; + } + + bitset_str += TAB_SEPARATOR; + bitset_str += "bitfield<"; + bitset_str += std::to_string(bits[index]); + + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member->get_descriptor(member_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + TypeKind default_type_kind; + ret = get_default_type_kind(bits[index], default_type_kind); + + if (ret != RETCODE_OK) + { + return ret; + } + + // WARNING: If a user had explicitly set the type to be the default type, the serialization to IDL will not + // set it explicitly. + if (member_descriptor->type()->get_kind() != default_type_kind) + { + // The type of the bitfield is not the default type. Write it. + std::string type_str; + dyn_type_to_str(member_descriptor->type(), type_str); + + bitset_str += ", "; + bitset_str += type_str; + } + + bitset_str += "> "; + bitset_str += member->get_name().to_string(); + bitset_str += ";\n"; + + bits_set += bits[index]; + } + + // Close definition + bitset_str += TYPE_CLOSURE; + + return ret; +} + ReturnCode_t node_to_str( const utilities::collections::TreeNode& node, std::string& node_str) noexcept @@ -736,6 +838,39 @@ ReturnCode_t node_to_str( return RETCODE_OK; } +ReturnCode_t get_default_type_kind( + const std::uint32_t size, + TypeKind& default_type) noexcept +{ + if (size == 1) + { + default_type = TK_BOOLEAN; + } + else if (size <= 8) + { + default_type = TK_UINT8; + } + else if (size <= 16) + { + default_type = TK_UINT16; + } + else if (size <= 32) + { + default_type = TK_UINT32; + } + else if (size <= 64) + { + default_type = TK_UINT64; + } + else + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Size is not supported."); + return RETCODE_BAD_PARAMETER; + } + + return RETCODE_OK; +} + } // namespace dds } // namespace fastdds } // namespace eprosima From 4502ffaf2bac01ff42fd6377284582beb75d3281 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 10:11:05 +0200 Subject: [PATCH 22/52] Tests - TK_BITSET Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 43 ++-- .../types/idls/bitset_struct.idl | 13 + .../bitset_struct/bitset_struct.hpp | 228 +++++++++++++++++ .../bitset_struct/bitset_structCdrAux.hpp | 46 ++++ .../bitset_struct/bitset_structCdrAux.ipp | 176 ++++++++++++++ .../bitset_structPubSubTypes.cxx | 229 ++++++++++++++++++ .../bitset_struct/bitset_structPubSubTypes.h | 133 ++++++++++ .../bitset_structTypeObjectSupport.cxx | 175 +++++++++++++ .../bitset_structTypeObjectSupport.hpp | 68 ++++++ 10 files changed, 1097 insertions(+), 18 deletions(-) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index da149c44bcf..489afd57f65 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -56,6 +56,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitset_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitset_struct.idl + COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynamicTypeSerializationTests.cpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index 66a6c2a8f67..327b87a27ef 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -26,39 +26,41 @@ #include -#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" -#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" - -#include "type_objects/basic_array_struct/basic_array_struct.hpp" -#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" +#include "type_objects/hello_world/hello_world.hpp" +#include "type_objects/hello_world/hello_worldPubSubTypes.h" -#include "type_objects/basic_struct/basic_struct.hpp" -#include "type_objects/basic_struct/basic_structPubSubTypes.h" +#include "type_objects/numeric_array/numeric_array.hpp" +#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" #include "type_objects/char_sequence/char_sequence.hpp" #include "type_objects/char_sequence/char_sequencePubSubTypes.h" -#include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" -#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h" +#include "type_objects/basic_struct/basic_struct.hpp" +#include "type_objects/basic_struct/basic_structPubSubTypes.h" -#include "type_objects/enum_struct/enum_struct.hpp" -#include "type_objects/enum_struct/enum_structPubSubTypes.h" +#include "type_objects/basic_array_struct/basic_array_struct.hpp" +#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" #include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" #include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" -#include "type_objects/hello_world/hello_world.hpp" -#include "type_objects/hello_world/hello_worldPubSubTypes.h" +#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" +#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" -#include "type_objects/map_struct/map_struct.hpp" -#include "type_objects/map_struct/map_structPubSubTypes.h" +#include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" +#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h" -#include "type_objects/numeric_array/numeric_array.hpp" -#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" +#include "type_objects/enum_struct/enum_struct.hpp" +#include "type_objects/enum_struct/enum_structPubSubTypes.h" #include "type_objects/union_struct/union_struct.hpp" #include "type_objects/union_struct/union_structPubSubTypes.h" +#include "type_objects/map_struct/map_struct.hpp" +#include "type_objects/map_struct/map_structPubSubTypes.h" + +#include "type_objects/bitset_struct/bitset_struct.hpp" +#include "type_objects/bitset_struct/bitset_structPubSubTypes.h" namespace test { @@ -75,6 +77,7 @@ const std::string COMPLEX_NESTED_ARRAYS{"complex_nested_arrays"}; const std::string ENUM_STRUCT{"enum_struct"}; const std::string UNION_STRUCT{"union_struct"}; const std::string MAP_STRUCT{"map_struct"}; +const std::string BITSET_STRUCT{"bitset_struct"}; } // namespace SupportedTypes @@ -89,7 +92,8 @@ const std::vector supported_types = { SupportedTypes::COMPLEX_NESTED_ARRAYS, SupportedTypes::ENUM_STRUCT, SupportedTypes::UNION_STRUCT, - SupportedTypes::MAP_STRUCT + SupportedTypes::MAP_STRUCT, + SupportedTypes::BITSET_STRUCT }; void register_dynamic_types() @@ -128,6 +132,9 @@ void register_dynamic_types() TypeSupport type_map_struct(new map_structPubSubType()); type_map_struct->register_type_object_representation(); + + TypeSupport type_bitset_struct(new bitset_structPubSubType()); + type_bitset_struct->register_type_object_representation(); } } /* namespace test */ diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl new file mode 100644 index 00000000000..a8be993ab69 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl @@ -0,0 +1,13 @@ +bitset ColorBitset +{ + bitfield<3> red; + bitfield<1> green; + bitfield<4>; + bitfield<10> blue; + bitfield<12, short> yellow; +}; + +struct bitset_struct +{ + ColorBitset my_bitset; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp new file mode 100644 index 00000000000..316e02f2e12 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp @@ -0,0 +1,228 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_BITSET_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(BITSET_STRUCT_SOURCE) +#define BITSET_STRUCT_DllAPI __declspec( dllexport ) +#else +#define BITSET_STRUCT_DllAPI __declspec( dllimport ) +#endif // BITSET_STRUCT_SOURCE +#else +#define BITSET_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define BITSET_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This structure represents the bitset ColorBitset defined by the user in the IDL file. + * @ingroup bitset_struct + */ +struct ColorBitset +{ + uint8_t red : 3; + + bool green : 1; + + uint8_t : 4; + + uint16_t blue : 10; + + int16_t yellow : 12; + + + /*! + * @brief Comparison operator. + * @param x ColorBitset object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ColorBitset& x) const + { + return (red == x.red && + green == x.green && + blue == x.blue && + yellow == x.yellow); + } + + /*! + * @brief Comparison operator. + * @param x ColorBitset object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ColorBitset& x) const + { + return !(*this == x); + } +}; +/*! + * @brief This class represents the structure bitset_struct defined by the user in the IDL file. + * @ingroup bitset_struct + */ +class bitset_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport bitset_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~bitset_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object bitset_struct that will be copied. + */ + eProsima_user_DllExport bitset_struct( + const bitset_struct& x) + { + m_my_bitset = x.m_my_bitset; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object bitset_struct that will be copied. + */ + eProsima_user_DllExport bitset_struct( + bitset_struct&& x) noexcept + { + m_my_bitset = std::move(x.m_my_bitset); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object bitset_struct that will be copied. + */ + eProsima_user_DllExport bitset_struct& operator =( + const bitset_struct& x) + { + + m_my_bitset = x.m_my_bitset; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object bitset_struct that will be copied. + */ + eProsima_user_DllExport bitset_struct& operator =( + bitset_struct&& x) noexcept + { + + m_my_bitset = std::move(x.m_my_bitset); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x bitset_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const bitset_struct& x) const + { + return (m_my_bitset == x.m_my_bitset); + } + + /*! + * @brief Comparison operator. + * @param x bitset_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const bitset_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_bitset + * @param _my_bitset New value to be copied in member my_bitset + */ + eProsima_user_DllExport void my_bitset( + const ColorBitset& _my_bitset) + { + m_my_bitset = _my_bitset; + } + + /*! + * @brief This function moves the value in member my_bitset + * @param _my_bitset New value to be moved in member my_bitset + */ + eProsima_user_DllExport void my_bitset( + ColorBitset&& _my_bitset) + { + m_my_bitset = std::move(_my_bitset); + } + + /*! + * @brief This function returns a constant reference to member my_bitset + * @return Constant reference to member my_bitset + */ + eProsima_user_DllExport const ColorBitset& my_bitset() const + { + return m_my_bitset; + } + + /*! + * @brief This function returns a reference to member my_bitset + * @return Reference to member my_bitset + */ + eProsima_user_DllExport ColorBitset& my_bitset() + { + return m_my_bitset; + } + + + +private: + + ColorBitset m_my_bitset{}; + +}; + +#endif // _FAST_DDS_GENERATED_BITSET_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp new file mode 100644 index 00000000000..f1bc5d159d4 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ + +#include "bitset_struct.hpp" + +constexpr uint32_t bitset_struct_max_cdr_typesize {8UL}; +constexpr uint32_t bitset_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const bitset_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp new file mode 100644 index 00000000000..0901d76b93e --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp @@ -0,0 +1,176 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ + +#include "bitset_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ColorBitset&, + size_t& current_alignment) +{ + return calculator.calculate_serialized_size(std::bitset<30>{}, current_alignment); +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ColorBitset& data) +{ + std::bitset<30> bitset; + + bitset <<= 12; + bitset |= (data.yellow & 0xFFF); + + bitset <<= 10; + bitset |= (data.blue & 0x3FF); + + bitset <<= 4; + + bitset <<= 1; + bitset |= (data.green & 0x1); + + bitset <<= 3; + bitset |= (data.red & 0x7); + + + scdr << bitset; +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& dcdr, + ColorBitset& data) +{ + std::bitset<30> bitset; + dcdr >> bitset; + + data.red = static_cast(bitset.to_ullong() & 0x7); + bitset >>= 3; + + data.green = static_cast(bitset.to_ullong() & 0x1); + bitset >>= 1; + + bitset >>= 4; + + data.blue = static_cast(bitset.to_ullong() & 0x3FF); + bitset >>= 10; + + data.yellow = static_cast(bitset.to_ullong() & 0xFFF); + bitset >>= 12; + +} + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const bitset_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_bitset(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const bitset_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_bitset() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + bitset_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_bitset(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const bitset_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx new file mode 100644 index 00000000000..ff45facbc19 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "bitset_structPubSubTypes.h" + +#include +#include + +#include "bitset_structCdrAux.hpp" +#include "bitset_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +bitset_structPubSubType::bitset_structPubSubType() +{ + setName("bitset_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(bitset_struct::getMaxCdrSerializedSize()); +#else + bitset_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = bitset_struct_max_key_cdr_typesize > 16 ? bitset_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +bitset_structPubSubType::~bitset_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool bitset_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + bitset_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool bitset_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + bitset_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function bitset_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* bitset_structPubSubType::createData() +{ + return reinterpret_cast(new bitset_struct()); +} + +void bitset_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool bitset_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + bitset_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + bitset_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || bitset_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void bitset_structPubSubType::register_type_object_representation() +{ + register_bitset_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "bitset_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h new file mode 100644 index 00000000000..cbfaa2bd9b4 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "bitset_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated bitset_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type bitset_struct defined by the user in the IDL file. + * @ingroup bitset_struct + */ +class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef bitset_struct type; + + eProsima_user_DllExport bitset_structPubSubType(); + + eProsima_user_DllExport ~bitset_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..0cf11b79410 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx @@ -0,0 +1,175 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "bitset_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "bitset_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +void register_ColorBitset_type_identifier( + TypeIdentifierPair& type_ids_ColorBitset) +{ + ReturnCode_t return_code_ColorBitset {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ColorBitset = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorBitset", type_ids_ColorBitset); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ColorBitset) + { + BitsetTypeFlag bitset_flags_ColorBitset = 0; + QualifiedTypeName type_name_ColorBitset = "ColorBitset"; + eprosima::fastcdr::optional type_ann_builtin_ColorBitset; + eprosima::fastcdr::optional ann_custom_ColorBitset; + CompleteTypeDetail detail_ColorBitset = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ColorBitset, ann_custom_ColorBitset, type_name_ColorBitset.to_string()); + CompleteBitsetHeader header_ColorBitset = TypeObjectUtils::build_complete_bitset_header(detail_ColorBitset); + CompleteBitfieldSeq field_seq_ColorBitset; + { + uint16_t position_red = 0; + BitsetMemberFlag flags_red = 0; + uint8_t bitcount_red = 3; + TypeKind holder_type_red = TK_BYTE; + CommonBitfield common_red = TypeObjectUtils::build_common_bitfield(position_red, flags_red, bitcount_red, holder_type_red); + eprosima::fastcdr::optional member_ann_builtin_red; + ann_custom_ColorBitset.reset(); + MemberName name_red = "red"; + CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_ColorBitset); + CompleteBitfield bitfield_red = TypeObjectUtils::build_complete_bitfield(common_red, detail_red); + TypeObjectUtils::add_complete_bitfield(field_seq_ColorBitset, bitfield_red); + } + { + uint16_t position_green = 3; + BitsetMemberFlag flags_green = 0; + uint8_t bitcount_green = 1; + TypeKind holder_type_green = TK_BOOLEAN; + CommonBitfield common_green = TypeObjectUtils::build_common_bitfield(position_green, flags_green, bitcount_green, holder_type_green); + eprosima::fastcdr::optional member_ann_builtin_green; + ann_custom_ColorBitset.reset(); + MemberName name_green = "green"; + CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_ColorBitset); + CompleteBitfield bitfield_green = TypeObjectUtils::build_complete_bitfield(common_green, detail_green); + TypeObjectUtils::add_complete_bitfield(field_seq_ColorBitset, bitfield_green); + } + { + uint16_t position_blue = 8; + BitsetMemberFlag flags_blue = 0; + uint8_t bitcount_blue = 10; + TypeKind holder_type_blue = TK_UINT16; + CommonBitfield common_blue = TypeObjectUtils::build_common_bitfield(position_blue, flags_blue, bitcount_blue, holder_type_blue); + eprosima::fastcdr::optional member_ann_builtin_blue; + ann_custom_ColorBitset.reset(); + MemberName name_blue = "blue"; + CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_ColorBitset); + CompleteBitfield bitfield_blue = TypeObjectUtils::build_complete_bitfield(common_blue, detail_blue); + TypeObjectUtils::add_complete_bitfield(field_seq_ColorBitset, bitfield_blue); + } + { + uint16_t position_yellow = 18; + BitsetMemberFlag flags_yellow = 0; + uint8_t bitcount_yellow = 12; + TypeKind holder_type_yellow = TK_INT16; + CommonBitfield common_yellow = TypeObjectUtils::build_common_bitfield(position_yellow, flags_yellow, bitcount_yellow, holder_type_yellow); + eprosima::fastcdr::optional member_ann_builtin_yellow; + ann_custom_ColorBitset.reset(); + MemberName name_yellow = "yellow"; + CompleteMemberDetail detail_yellow = TypeObjectUtils::build_complete_member_detail(name_yellow, member_ann_builtin_yellow, ann_custom_ColorBitset); + CompleteBitfield bitfield_yellow = TypeObjectUtils::build_complete_bitfield(common_yellow, detail_yellow); + TypeObjectUtils::add_complete_bitfield(field_seq_ColorBitset, bitfield_yellow); + } + CompleteBitsetType bitset_type_ColorBitset = TypeObjectUtils::build_complete_bitset_type(bitset_flags_ColorBitset, header_ColorBitset, field_seq_ColorBitset); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_bitset_type_object(bitset_type_ColorBitset, + type_name_ColorBitset.to_string(), type_ids_ColorBitset)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ColorBitset already registered in TypeObjectRegistry for a different type."); + } + } +}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_bitset_struct_type_identifier( + TypeIdentifierPair& type_ids_bitset_struct) +{ + + ReturnCode_t return_code_bitset_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_bitset_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "bitset_struct", type_ids_bitset_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_bitset_struct) + { + StructTypeFlag struct_flags_bitset_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_bitset_struct = "bitset_struct"; + eprosima::fastcdr::optional type_ann_builtin_bitset_struct; + eprosima::fastcdr::optional ann_custom_bitset_struct; + CompleteTypeDetail detail_bitset_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_bitset_struct, ann_custom_bitset_struct, type_name_bitset_struct.to_string()); + CompleteStructHeader header_bitset_struct; + header_bitset_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_bitset_struct); + CompleteStructMemberSeq member_seq_bitset_struct; + { + TypeIdentifierPair type_ids_my_bitset; + ReturnCode_t return_code_my_bitset {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bitset = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorBitset", type_ids_my_bitset); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bitset) + { + ::register_ColorBitset_type_identifier(type_ids_my_bitset); + } + StructMemberFlag member_flags_my_bitset = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bitset = 0x00000000; + bool common_my_bitset_ec {false}; + CommonStructMember common_my_bitset {TypeObjectUtils::build_common_struct_member(member_id_my_bitset, member_flags_my_bitset, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bitset, common_my_bitset_ec))}; + if (!common_my_bitset_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bitset member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bitset = "my_bitset"; + eprosima::fastcdr::optional member_ann_builtin_my_bitset; + ann_custom_bitset_struct.reset(); + CompleteMemberDetail detail_my_bitset = TypeObjectUtils::build_complete_member_detail(name_my_bitset, member_ann_builtin_my_bitset, ann_custom_bitset_struct); + CompleteStructMember member_my_bitset = TypeObjectUtils::build_complete_struct_member(common_my_bitset, detail_my_bitset); + TypeObjectUtils::add_complete_struct_member(member_seq_bitset_struct, member_my_bitset); + } + CompleteStructType struct_type_bitset_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_bitset_struct, header_bitset_struct, member_seq_bitset_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_bitset_struct, type_name_bitset_struct.to_string(), type_ids_bitset_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "bitset_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..57c4ef7315d --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitset_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register ColorBitset related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ColorBitset_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register bitset_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_bitset_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From abaa9f53b5c47f8bef2fdd1a2c64254e761964cf Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 12:41:08 +0200 Subject: [PATCH 23/52] Support TK_BITMASK Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 10 +++ .../xtypes/type_conversion/dyn_type_tree.ipp | 88 ++++++++++++++++++- 2 files changed, 97 insertions(+), 1 deletion(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index ca80f473daa..63c45f57d7f 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -196,6 +196,16 @@ ReturnCode_t bitset_to_str( const utilities::collections::TreeNode& node, std::string& bitset_str) noexcept; +/** + * @brief Converts a tree with a \c TK_BITMASK root to an IDL string. + * + * @param node The root node of the tree. + * @param union_str The string representation of the tree. + */ +ReturnCode_t bitmask_to_str( + const utilities::collections::TreeNode& node, + std::string& bitset_str) noexcept; + /** * @brief Converts a simple tree to an IDL string. * diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index c0f3026e54b..ed69afe2154 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -245,11 +245,11 @@ ReturnCode_t dyn_type_to_str( case TK_ENUM: case TK_UNION: case TK_BITSET: + case TK_BITMASK: { type_str = dyn_type->get_name().to_string(); break; } - case TK_BITMASK: case TK_NONE: case TK_ALIAS: { @@ -530,6 +530,11 @@ ReturnCode_t dyn_type_tree_to_idl( ret = bitset_to_str(node, kind_str); break; } + case TK_BITMASK: + { + ret = bitmask_to_str(node, kind_str); + break; + } default: { continue; @@ -809,6 +814,87 @@ ReturnCode_t bitset_to_str( return ret; } +ReturnCode_t bitmask_to_str( + const utilities::collections::TreeNode& node, + std::string& bitset_str) noexcept +{ + if (node.info.dynamic_type->get_kind() != TK_BITMASK) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitmask."); + return RETCODE_BAD_PARAMETER; + } + + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + if (type_descriptor->bound().size() != 1) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Bitmask type must have exactly one bound."); + return RETCODE_BAD_PARAMETER; + } + + // Annotation with the bitmask size + static constexpr std::uint32_t DEFAULT_BITMASK_SIZE = 32; + const auto bitmask_size = type_descriptor->bound()[0]; + + if (bitmask_size != DEFAULT_BITMASK_SIZE) + { + bitset_str = "@bit_bound(" + std::to_string(bitmask_size) + ")\n"; + } + + bitset_str += "bitmask " + node.info.type_kind_name + TYPE_OPENING; + + const auto member_count = node.info.dynamic_type->get_member_count(); + + std::uint32_t pos = 0; + + for (std::uint32_t index = 0; index < member_count; index++) + { + traits::ref_type member; + ret = node.info.dynamic_type->get_member_by_index(member, index); + + if (ret != RETCODE_OK) + { + return ret; + } + + bitset_str += TAB_SEPARATOR; + + // Annotation with the position + const auto id = member->get_id(); + + if (id != pos) + { + bitset_str += "@position(" + std::to_string(id) + ") "; + } + + bitset_str += member->get_name().to_string(); + + // Add comma if not last member + if (index < member_count - 1) + { + bitset_str += ","; + } + + bitset_str += "\n"; + + // The position is always sequential + pos = id + 1; + } + + // Close definition + bitset_str += TYPE_CLOSURE; + + return ret; +} + ReturnCode_t node_to_str( const utilities::collections::TreeNode& node, std::string& node_str) noexcept From a4c5bdb179f52cac148d4b186217948368182ef5 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 12:41:37 +0200 Subject: [PATCH 24/52] Tests - TK_BITMASK Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 10 +- .../types/idls/bitmask_struct.idl | 13 + .../bitmask_struct/bitmask_struct.hpp | 200 +++++++++++++++ .../bitmask_struct/bitmask_structCdrAux.hpp | 47 ++++ .../bitmask_struct/bitmask_structCdrAux.ipp | 118 +++++++++ .../bitmask_structPubSubTypes.cxx | 229 ++++++++++++++++++ .../bitmask_structPubSubTypes.h | 133 ++++++++++ .../bitmask_structTypeObjectSupport.cxx | 186 ++++++++++++++ .../bitmask_structTypeObjectSupport.hpp | 68 ++++++ 10 files changed, 1007 insertions(+), 1 deletion(-) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index 489afd57f65..dd25ade319d 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -60,6 +60,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitset_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitset_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitmask_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitmask_struct.idl + COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynamicTypeSerializationTests.cpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index 327b87a27ef..04a71da7766 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -62,6 +62,9 @@ #include "type_objects/bitset_struct/bitset_struct.hpp" #include "type_objects/bitset_struct/bitset_structPubSubTypes.h" +#include "type_objects/bitmask_struct/bitmask_struct.hpp" +#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.h" + namespace test { namespace SupportedTypes { @@ -78,6 +81,7 @@ const std::string ENUM_STRUCT{"enum_struct"}; const std::string UNION_STRUCT{"union_struct"}; const std::string MAP_STRUCT{"map_struct"}; const std::string BITSET_STRUCT{"bitset_struct"}; +const std::string BITMASK_STRUCT{"bitmask_struct"}; } // namespace SupportedTypes @@ -93,7 +97,8 @@ const std::vector supported_types = { SupportedTypes::ENUM_STRUCT, SupportedTypes::UNION_STRUCT, SupportedTypes::MAP_STRUCT, - SupportedTypes::BITSET_STRUCT + SupportedTypes::BITSET_STRUCT, + SupportedTypes::BITMASK_STRUCT }; void register_dynamic_types() @@ -135,6 +140,9 @@ void register_dynamic_types() TypeSupport type_bitset_struct(new bitset_structPubSubType()); type_bitset_struct->register_type_object_representation(); + + TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); + type_bitmask_struct->register_type_object_representation(); } } /* namespace test */ diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl new file mode 100644 index 00000000000..02afbaa323f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl @@ -0,0 +1,13 @@ +@bit_bound(8) +bitmask ColorBitmask +{ + red, + @position(2) green, + blue, + @position(5) yellow +}; + +struct bitmask_struct +{ + ColorBitmask my_bitmask; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp new file mode 100644 index 00000000000..24d770fb959 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp @@ -0,0 +1,200 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_BITMASK_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(BITMASK_STRUCT_SOURCE) +#define BITMASK_STRUCT_DllAPI __declspec( dllexport ) +#else +#define BITMASK_STRUCT_DllAPI __declspec( dllimport ) +#endif // BITMASK_STRUCT_SOURCE +#else +#define BITMASK_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define BITMASK_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This enumeration represents the ColorBitmask bitflags defined by the user in the IDL file. + * @ingroup bitmask_struct + */ +enum ColorBitmaskBits : uint8_t +{ + red = 0x01ull << 0, + green = 0x01ull << 2, + blue = 0x01ull << 3, + yellow = 0x01ull << 5 +}; +typedef uint8_t ColorBitmask; +/*! + * @brief This class represents the structure bitmask_struct defined by the user in the IDL file. + * @ingroup bitmask_struct + */ +class bitmask_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport bitmask_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~bitmask_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object bitmask_struct that will be copied. + */ + eProsima_user_DllExport bitmask_struct( + const bitmask_struct& x) + { + m_my_bitmask = x.m_my_bitmask; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object bitmask_struct that will be copied. + */ + eProsima_user_DllExport bitmask_struct( + bitmask_struct&& x) noexcept + { + m_my_bitmask = std::move(x.m_my_bitmask); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object bitmask_struct that will be copied. + */ + eProsima_user_DllExport bitmask_struct& operator =( + const bitmask_struct& x) + { + + m_my_bitmask = x.m_my_bitmask; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object bitmask_struct that will be copied. + */ + eProsima_user_DllExport bitmask_struct& operator =( + bitmask_struct&& x) noexcept + { + + m_my_bitmask = std::move(x.m_my_bitmask); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x bitmask_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const bitmask_struct& x) const + { + return (m_my_bitmask == x.m_my_bitmask); + } + + /*! + * @brief Comparison operator. + * @param x bitmask_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const bitmask_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_bitmask + * @param _my_bitmask New value to be copied in member my_bitmask + */ + eProsima_user_DllExport void my_bitmask( + const ColorBitmask& _my_bitmask) + { + m_my_bitmask = _my_bitmask; + } + + /*! + * @brief This function moves the value in member my_bitmask + * @param _my_bitmask New value to be moved in member my_bitmask + */ + eProsima_user_DllExport void my_bitmask( + ColorBitmask&& _my_bitmask) + { + m_my_bitmask = std::move(_my_bitmask); + } + + /*! + * @brief This function returns a constant reference to member my_bitmask + * @return Constant reference to member my_bitmask + */ + eProsima_user_DllExport const ColorBitmask& my_bitmask() const + { + return m_my_bitmask; + } + + /*! + * @brief This function returns a reference to member my_bitmask + * @return Reference to member my_bitmask + */ + eProsima_user_DllExport ColorBitmask& my_bitmask() + { + return m_my_bitmask; + } + + + +private: + + ColorBitmask m_my_bitmask{0}; + +}; + +#endif // _FAST_DDS_GENERATED_BITMASK_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp new file mode 100644 index 00000000000..18dcad3ce11 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp @@ -0,0 +1,47 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ + +#include "bitmask_struct.hpp" + +constexpr uint32_t bitmask_struct_max_cdr_typesize {5UL}; +constexpr uint32_t bitmask_struct_max_key_cdr_typesize {0UL}; + + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const bitmask_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp new file mode 100644 index 00000000000..4d520739874 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ + +#include "bitmask_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const bitmask_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_bitmask(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const bitmask_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_bitmask() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + bitmask_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_bitmask(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const bitmask_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx new file mode 100644 index 00000000000..2bc4cc6fe0b --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "bitmask_structPubSubTypes.h" + +#include +#include + +#include "bitmask_structCdrAux.hpp" +#include "bitmask_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +bitmask_structPubSubType::bitmask_structPubSubType() +{ + setName("bitmask_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(bitmask_struct::getMaxCdrSerializedSize()); +#else + bitmask_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = bitmask_struct_max_key_cdr_typesize > 16 ? bitmask_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +bitmask_structPubSubType::~bitmask_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool bitmask_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + bitmask_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool bitmask_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + bitmask_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function bitmask_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* bitmask_structPubSubType::createData() +{ + return reinterpret_cast(new bitmask_struct()); +} + +void bitmask_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool bitmask_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + bitmask_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + bitmask_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || bitmask_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void bitmask_structPubSubType::register_type_object_representation() +{ + register_bitmask_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "bitmask_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h new file mode 100644 index 00000000000..1bc99c35a6c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "bitmask_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated bitmask_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type bitmask_struct defined by the user in the IDL file. + * @ingroup bitmask_struct + */ +class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef bitmask_struct type; + + eProsima_user_DllExport bitmask_structPubSubType(); + + eProsima_user_DllExport ~bitmask_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..b4bb192c816 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx @@ -0,0 +1,186 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "bitmask_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "bitmask_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +void register_ColorBitmask_type_identifier( + TypeIdentifierPair& type_ids_ColorBitmask) +{ + ReturnCode_t return_code_ColorBitmask {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ColorBitmask = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorBitmask", type_ids_ColorBitmask); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ColorBitmask) + { + BitmaskTypeFlag bitmask_flags_ColorBitmask = 0; + BitBound bit_bound_ColorBitmask = 8; + CommonEnumeratedHeader common_ColorBitmask = TypeObjectUtils::build_common_enumerated_header(bit_bound_ColorBitmask, true); + QualifiedTypeName type_name_ColorBitmask = "ColorBitmask"; + eprosima::fastcdr::optional type_ann_builtin_ColorBitmask; + eprosima::fastcdr::optional ann_custom_ColorBitmask; + AppliedAnnotationSeq tmp_ann_custom_ColorBitmask; + eprosima::fastcdr::optional verbatim_ColorBitmask; + if (!tmp_ann_custom_ColorBitmask.empty()) + { + ann_custom_ColorBitmask = tmp_ann_custom_ColorBitmask; + } + + CompleteTypeDetail detail_ColorBitmask = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ColorBitmask, ann_custom_ColorBitmask, type_name_ColorBitmask.to_string()); + CompleteEnumeratedHeader header_ColorBitmask = TypeObjectUtils::build_complete_enumerated_header(common_ColorBitmask, detail_ColorBitmask, true); + CompleteBitflagSeq flag_seq_ColorBitmask; + { + uint16_t position_red = 0; + BitflagFlag flags_red = 0; + CommonBitflag common_red = TypeObjectUtils::build_common_bitflag(position_red, flags_red); + eprosima::fastcdr::optional member_ann_builtin_red; + ann_custom_ColorBitmask.reset(); + MemberName name_red = "red"; + CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_ColorBitmask); + CompleteBitflag bitflag_red = TypeObjectUtils::build_complete_bitflag(common_red, detail_red); + TypeObjectUtils::add_complete_bitflag(flag_seq_ColorBitmask, bitflag_red); + } + { + uint16_t position_green = 2; + BitflagFlag flags_green = 0; + CommonBitflag common_green = TypeObjectUtils::build_common_bitflag(position_green, flags_green); + eprosima::fastcdr::optional member_ann_builtin_green; + ann_custom_ColorBitmask.reset(); + AppliedAnnotationSeq tmp_ann_custom_green; + if (!tmp_ann_custom_green.empty()) + { + ann_custom_ColorBitmask = tmp_ann_custom_green; + } + MemberName name_green = "green"; + CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_ColorBitmask); + CompleteBitflag bitflag_green = TypeObjectUtils::build_complete_bitflag(common_green, detail_green); + TypeObjectUtils::add_complete_bitflag(flag_seq_ColorBitmask, bitflag_green); + } + { + uint16_t position_blue = 3; + BitflagFlag flags_blue = 0; + CommonBitflag common_blue = TypeObjectUtils::build_common_bitflag(position_blue, flags_blue); + eprosima::fastcdr::optional member_ann_builtin_blue; + ann_custom_ColorBitmask.reset(); + MemberName name_blue = "blue"; + CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_ColorBitmask); + CompleteBitflag bitflag_blue = TypeObjectUtils::build_complete_bitflag(common_blue, detail_blue); + TypeObjectUtils::add_complete_bitflag(flag_seq_ColorBitmask, bitflag_blue); + } + { + uint16_t position_yellow = 5; + BitflagFlag flags_yellow = 0; + CommonBitflag common_yellow = TypeObjectUtils::build_common_bitflag(position_yellow, flags_yellow); + eprosima::fastcdr::optional member_ann_builtin_yellow; + ann_custom_ColorBitmask.reset(); + AppliedAnnotationSeq tmp_ann_custom_yellow; + if (!tmp_ann_custom_yellow.empty()) + { + ann_custom_ColorBitmask = tmp_ann_custom_yellow; + } + MemberName name_yellow = "yellow"; + CompleteMemberDetail detail_yellow = TypeObjectUtils::build_complete_member_detail(name_yellow, member_ann_builtin_yellow, ann_custom_ColorBitmask); + CompleteBitflag bitflag_yellow = TypeObjectUtils::build_complete_bitflag(common_yellow, detail_yellow); + TypeObjectUtils::add_complete_bitflag(flag_seq_ColorBitmask, bitflag_yellow); + } + CompleteBitmaskType bitmask_type_ColorBitmask = TypeObjectUtils::build_complete_bitmask_type(bitmask_flags_ColorBitmask, header_ColorBitmask, flag_seq_ColorBitmask); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_bitmask_type_object(bitmask_type_ColorBitmask, + type_name_ColorBitmask.to_string(), type_ids_ColorBitmask)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ColorBitmask already registered in TypeObjectRegistry for a different type."); + } + } +}// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_bitmask_struct_type_identifier( + TypeIdentifierPair& type_ids_bitmask_struct) +{ + + ReturnCode_t return_code_bitmask_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_bitmask_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "bitmask_struct", type_ids_bitmask_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_bitmask_struct) + { + StructTypeFlag struct_flags_bitmask_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_bitmask_struct = "bitmask_struct"; + eprosima::fastcdr::optional type_ann_builtin_bitmask_struct; + eprosima::fastcdr::optional ann_custom_bitmask_struct; + CompleteTypeDetail detail_bitmask_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_bitmask_struct, ann_custom_bitmask_struct, type_name_bitmask_struct.to_string()); + CompleteStructHeader header_bitmask_struct; + header_bitmask_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_bitmask_struct); + CompleteStructMemberSeq member_seq_bitmask_struct; + { + TypeIdentifierPair type_ids_my_bitmask; + ReturnCode_t return_code_my_bitmask {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bitmask = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorBitmask", type_ids_my_bitmask); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bitmask) + { + ::register_ColorBitmask_type_identifier(type_ids_my_bitmask); + } + StructMemberFlag member_flags_my_bitmask = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bitmask = 0x00000000; + bool common_my_bitmask_ec {false}; + CommonStructMember common_my_bitmask {TypeObjectUtils::build_common_struct_member(member_id_my_bitmask, member_flags_my_bitmask, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bitmask, common_my_bitmask_ec))}; + if (!common_my_bitmask_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bitmask member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bitmask = "my_bitmask"; + eprosima::fastcdr::optional member_ann_builtin_my_bitmask; + ann_custom_bitmask_struct.reset(); + CompleteMemberDetail detail_my_bitmask = TypeObjectUtils::build_complete_member_detail(name_my_bitmask, member_ann_builtin_my_bitmask, ann_custom_bitmask_struct); + CompleteStructMember member_my_bitmask = TypeObjectUtils::build_complete_struct_member(common_my_bitmask, detail_my_bitmask); + TypeObjectUtils::add_complete_struct_member(member_seq_bitmask_struct, member_my_bitmask); + } + CompleteStructType struct_type_bitmask_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_bitmask_struct, header_bitmask_struct, member_seq_bitmask_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_bitmask_struct, type_name_bitmask_struct.to_string(), type_ids_bitmask_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "bitmask_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..c0caa908537 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file bitmask_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register ColorBitmask related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ColorBitmask_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register bitmask_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_bitmask_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From 6a36c4d30f508d66219ca7b7ca96aa3c7f318623 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 14:48:01 +0200 Subject: [PATCH 25/52] Support TK_ALIAS Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 10 +++++ .../xtypes/type_conversion/dyn_type_tree.ipp | 43 ++++++++++++++++++- 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index 63c45f57d7f..be5e032aba1 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -206,6 +206,16 @@ ReturnCode_t bitmask_to_str( const utilities::collections::TreeNode& node, std::string& bitset_str) noexcept; +/** + * @brief Converts a tree with a \c TK_ALIAS root to an IDL string. + * + * @param node The root node of the tree. + * @param alias_str The string representation of the tree. + */ +ReturnCode_t alias_to_str( + const utilities::collections::TreeNode& node, + std::string& alias_str) noexcept; + /** * @brief Converts a simple tree to an IDL string. * diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index ed69afe2154..e7b0e2e7a07 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -246,12 +246,12 @@ ReturnCode_t dyn_type_to_str( case TK_UNION: case TK_BITSET: case TK_BITMASK: + case TK_ALIAS: { type_str = dyn_type->get_name().to_string(); break; } case TK_NONE: - case TK_ALIAS: { ret = RETCODE_UNSUPPORTED; break; @@ -535,6 +535,11 @@ ReturnCode_t dyn_type_tree_to_idl( ret = bitmask_to_str(node, kind_str); break; } + case TK_ALIAS: + { + ret = alias_to_str(node, kind_str); + break; + } default: { continue; @@ -895,6 +900,42 @@ ReturnCode_t bitmask_to_str( return ret; } +ReturnCode_t alias_to_str( + const utilities::collections::TreeNode& node, + std::string& alias_str) noexcept +{ + if (node.info.dynamic_type->get_kind() != TK_ALIAS) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an alias."); + return RETCODE_BAD_PARAMETER; + } + + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Find the base type of the alias + std::string base_type_kind_str; + ret = dyn_type_to_str(type_descriptor->base_type(), base_type_kind_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + alias_str = "typedef "; + alias_str += base_type_kind_str + " "; + alias_str += type_descriptor->name().to_string() + ";\n"; + + return ret; +} + ReturnCode_t node_to_str( const utilities::collections::TreeNode& node, std::string& node_str) noexcept From 95f9e362babed6f4781311b7762e2254f8dd4914 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 15:30:37 +0200 Subject: [PATCH 26/52] Tests - TK_ALIAS Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 10 +- .../types/idls/alias_struct.idl | 12 + .../alias_struct/alias_struct.hpp | 258 +++++++++++++++ .../alias_struct/alias_structCdrAux.hpp | 49 +++ .../alias_struct/alias_structCdrAux.ipp | 134 ++++++++ .../alias_struct/alias_structPubSubTypes.cxx | 229 +++++++++++++ .../alias_struct/alias_structPubSubTypes.h | 136 ++++++++ .../alias_structTypeObjectSupport.cxx | 302 ++++++++++++++++++ .../alias_structTypeObjectSupport.hpp | 98 ++++++ 10 files changed, 1231 insertions(+), 1 deletion(-) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index dd25ade319d..d7194e12a79 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -64,6 +64,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitmask_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitmask_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/alias_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/alias_struct.idl + COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynamicTypeSerializationTests.cpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index 04a71da7766..c91ba0cc044 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -65,6 +65,9 @@ #include "type_objects/bitmask_struct/bitmask_struct.hpp" #include "type_objects/bitmask_struct/bitmask_structPubSubTypes.h" +#include "type_objects/alias_struct/alias_struct.hpp" +#include "type_objects/alias_struct/alias_structPubSubTypes.h" + namespace test { namespace SupportedTypes { @@ -82,6 +85,7 @@ const std::string UNION_STRUCT{"union_struct"}; const std::string MAP_STRUCT{"map_struct"}; const std::string BITSET_STRUCT{"bitset_struct"}; const std::string BITMASK_STRUCT{"bitmask_struct"}; +const std::string ALIAS_STRUCT{"alias_struct"}; } // namespace SupportedTypes @@ -98,7 +102,8 @@ const std::vector supported_types = { SupportedTypes::UNION_STRUCT, SupportedTypes::MAP_STRUCT, SupportedTypes::BITSET_STRUCT, - SupportedTypes::BITMASK_STRUCT + SupportedTypes::BITMASK_STRUCT, + SupportedTypes::ALIAS_STRUCT }; void register_dynamic_types() @@ -143,6 +148,9 @@ void register_dynamic_types() TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); type_bitmask_struct->register_type_object_representation(); + + TypeSupport type_alias_struct(new alias_structPubSubType()); + type_alias_struct->register_type_object_representation(); } } /* namespace test */ diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl new file mode 100644 index 00000000000..0a0f1d1db71 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl @@ -0,0 +1,12 @@ +typedef short MyShort; + +typedef unsigned long MyLong; + +typedef MyShort MyRecursiveShort; + +struct alias_struct +{ + MyShort my_short; + MyLong my_long; + MyRecursiveShort my_recursive_short; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp new file mode 100644 index 00000000000..0be2ee5c1df --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp @@ -0,0 +1,258 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_ALIAS_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(ALIAS_STRUCT_SOURCE) +#define ALIAS_STRUCT_DllAPI __declspec( dllexport ) +#else +#define ALIAS_STRUCT_DllAPI __declspec( dllimport ) +#endif // ALIAS_STRUCT_SOURCE +#else +#define ALIAS_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define ALIAS_STRUCT_DllAPI +#endif // _WIN32 + +typedef int16_t MyShort; + +typedef uint32_t MyLong; + +typedef MyShort MyRecursiveShort; + +/*! + * @brief This class represents the structure alias_struct defined by the user in the IDL file. + * @ingroup alias_struct + */ +class alias_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport alias_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~alias_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object alias_struct that will be copied. + */ + eProsima_user_DllExport alias_struct( + const alias_struct& x) + { + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_recursive_short = x.m_my_recursive_short; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object alias_struct that will be copied. + */ + eProsima_user_DllExport alias_struct( + alias_struct&& x) noexcept + { + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_recursive_short = x.m_my_recursive_short; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object alias_struct that will be copied. + */ + eProsima_user_DllExport alias_struct& operator =( + const alias_struct& x) + { + + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_recursive_short = x.m_my_recursive_short; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object alias_struct that will be copied. + */ + eProsima_user_DllExport alias_struct& operator =( + alias_struct&& x) noexcept + { + + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_recursive_short = x.m_my_recursive_short; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x alias_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const alias_struct& x) const + { + return (m_my_short == x.m_my_short && + m_my_long == x.m_my_long && + m_my_recursive_short == x.m_my_recursive_short); + } + + /*! + * @brief Comparison operator. + * @param x alias_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const alias_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short + */ + eProsima_user_DllExport void my_short( + MyShort _my_short) + { + m_my_short = _my_short; + } + + /*! + * @brief This function returns the value of member my_short + * @return Value of member my_short + */ + eProsima_user_DllExport MyShort my_short() const + { + return m_my_short; + } + + /*! + * @brief This function returns a reference to member my_short + * @return Reference to member my_short + */ + eProsima_user_DllExport MyShort& my_short() + { + return m_my_short; + } + + + /*! + * @brief This function sets a value in member my_long + * @param _my_long New value for member my_long + */ + eProsima_user_DllExport void my_long( + MyLong _my_long) + { + m_my_long = _my_long; + } + + /*! + * @brief This function returns the value of member my_long + * @return Value of member my_long + */ + eProsima_user_DllExport MyLong my_long() const + { + return m_my_long; + } + + /*! + * @brief This function returns a reference to member my_long + * @return Reference to member my_long + */ + eProsima_user_DllExport MyLong& my_long() + { + return m_my_long; + } + + + /*! + * @brief This function sets a value in member my_recursive_short + * @param _my_recursive_short New value for member my_recursive_short + */ + eProsima_user_DllExport void my_recursive_short( + MyRecursiveShort _my_recursive_short) + { + m_my_recursive_short = _my_recursive_short; + } + + /*! + * @brief This function returns the value of member my_recursive_short + * @return Value of member my_recursive_short + */ + eProsima_user_DllExport MyRecursiveShort my_recursive_short() const + { + return m_my_recursive_short; + } + + /*! + * @brief This function returns a reference to member my_recursive_short + * @return Reference to member my_recursive_short + */ + eProsima_user_DllExport MyRecursiveShort& my_recursive_short() + { + return m_my_recursive_short; + } + + + +private: + + MyShort m_my_short{0}; + MyLong m_my_long{0}; + MyRecursiveShort m_my_recursive_short{0}; + +}; + +#endif // _FAST_DDS_GENERATED_ALIAS_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp new file mode 100644 index 00000000000..5fc277cb939 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp @@ -0,0 +1,49 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ + +#include "alias_struct.hpp" + +constexpr uint32_t alias_struct_max_cdr_typesize {14UL}; +constexpr uint32_t alias_struct_max_key_cdr_typesize {0UL}; + + + + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const alias_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp new file mode 100644 index 00000000000..10094e3f928 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp @@ -0,0 +1,134 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ + +#include "alias_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const alias_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_short(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_long(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_recursive_short(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const alias_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_short() + << eprosima::fastcdr::MemberId(1) << data.my_long() + << eprosima::fastcdr::MemberId(2) << data.my_recursive_short() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + alias_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_short(); + break; + + case 1: + dcdr >> data.my_long(); + break; + + case 2: + dcdr >> data.my_recursive_short(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const alias_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx new file mode 100644 index 00000000000..7eba7f2c21a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "alias_structPubSubTypes.h" + +#include +#include + +#include "alias_structCdrAux.hpp" +#include "alias_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +alias_structPubSubType::alias_structPubSubType() +{ + setName("alias_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(alias_struct::getMaxCdrSerializedSize()); +#else + alias_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = alias_struct_max_key_cdr_typesize > 16 ? alias_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +alias_structPubSubType::~alias_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool alias_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + alias_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool alias_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + alias_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function alias_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* alias_structPubSubType::createData() +{ + return reinterpret_cast(new alias_struct()); +} + +void alias_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool alias_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + alias_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + alias_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || alias_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void alias_structPubSubType::register_type_object_representation() +{ + register_alias_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "alias_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h new file mode 100644 index 00000000000..647b2d3947a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h @@ -0,0 +1,136 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "alias_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated alias_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + +typedef int16_t MyShort; +typedef uint32_t MyLong; +typedef MyShort MyRecursiveShort; + +/*! + * @brief This class represents the TopicDataType of the type alias_struct defined by the user in the IDL file. + * @ingroup alias_struct + */ +class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef alias_struct type; + + eProsima_user_DllExport alias_structPubSubType(); + + eProsima_user_DllExport ~alias_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..834ef379b04 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx @@ -0,0 +1,302 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "alias_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "alias_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +void register_MyShort_type_identifier( + TypeIdentifierPair& type_ids_MyShort) +{ + ReturnCode_t return_code_MyShort {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyShort", type_ids_MyShort); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyShort) + { + AliasTypeFlag alias_flags_MyShort = 0; + QualifiedTypeName type_name_MyShort = "MyShort"; + eprosima::fastcdr::optional type_ann_builtin_MyShort; + eprosima::fastcdr::optional ann_custom_MyShort; + CompleteTypeDetail detail_MyShort = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyShort, ann_custom_MyShort, type_name_MyShort.to_string()); + CompleteAliasHeader header_MyShort = TypeObjectUtils::build_complete_alias_header(detail_MyShort); + AliasMemberFlag related_flags_MyShort = 0; + return_code_MyShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_MyShort); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyShort) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyShort related TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool common_MyShort_ec {false}; + CommonAliasBody common_MyShort {TypeObjectUtils::build_common_alias_body(related_flags_MyShort, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyShort, common_MyShort_ec))}; + if (!common_MyShort_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyShort related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyShort; + ann_custom_MyShort.reset(); + CompleteAliasBody body_MyShort = TypeObjectUtils::build_complete_alias_body(common_MyShort, + member_ann_builtin_MyShort, ann_custom_MyShort); + CompleteAliasType alias_type_MyShort = TypeObjectUtils::build_complete_alias_type(alias_flags_MyShort, + header_MyShort, body_MyShort); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyShort, + type_name_MyShort.to_string(), type_ids_MyShort)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyShort already registered in TypeObjectRegistry for a different type."); + } + } +} + +void register_MyLong_type_identifier( + TypeIdentifierPair& type_ids_MyLong) +{ + ReturnCode_t return_code_MyLong {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyLong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyLong", type_ids_MyLong); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) + { + AliasTypeFlag alias_flags_MyLong = 0; + QualifiedTypeName type_name_MyLong = "MyLong"; + eprosima::fastcdr::optional type_ann_builtin_MyLong; + eprosima::fastcdr::optional ann_custom_MyLong; + CompleteTypeDetail detail_MyLong = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyLong, ann_custom_MyLong, type_name_MyLong.to_string()); + CompleteAliasHeader header_MyLong = TypeObjectUtils::build_complete_alias_header(detail_MyLong); + AliasMemberFlag related_flags_MyLong = 0; + return_code_MyLong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_MyLong); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyLong related TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool common_MyLong_ec {false}; + CommonAliasBody common_MyLong {TypeObjectUtils::build_common_alias_body(related_flags_MyLong, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyLong, common_MyLong_ec))}; + if (!common_MyLong_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyLong related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyLong; + ann_custom_MyLong.reset(); + CompleteAliasBody body_MyLong = TypeObjectUtils::build_complete_alias_body(common_MyLong, + member_ann_builtin_MyLong, ann_custom_MyLong); + CompleteAliasType alias_type_MyLong = TypeObjectUtils::build_complete_alias_type(alias_flags_MyLong, + header_MyLong, body_MyLong); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyLong, + type_name_MyLong.to_string(), type_ids_MyLong)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyLong already registered in TypeObjectRegistry for a different type."); + } + } +} + +void register_MyRecursiveShort_type_identifier( + TypeIdentifierPair& type_ids_MyRecursiveShort) +{ + ReturnCode_t return_code_MyRecursiveShort {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyRecursiveShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyRecursiveShort", type_ids_MyRecursiveShort); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) + { + AliasTypeFlag alias_flags_MyRecursiveShort = 0; + QualifiedTypeName type_name_MyRecursiveShort = "MyRecursiveShort"; + eprosima::fastcdr::optional type_ann_builtin_MyRecursiveShort; + eprosima::fastcdr::optional ann_custom_MyRecursiveShort; + CompleteTypeDetail detail_MyRecursiveShort = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort, type_name_MyRecursiveShort.to_string()); + CompleteAliasHeader header_MyRecursiveShort = TypeObjectUtils::build_complete_alias_header(detail_MyRecursiveShort); + AliasMemberFlag related_flags_MyRecursiveShort = 0; + return_code_MyRecursiveShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyShort", type_ids_MyRecursiveShort); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) + { + ::register_MyShort_type_identifier(type_ids_MyRecursiveShort); + } + bool common_MyRecursiveShort_ec {false}; + CommonAliasBody common_MyRecursiveShort {TypeObjectUtils::build_common_alias_body(related_flags_MyRecursiveShort, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyRecursiveShort, common_MyRecursiveShort_ec))}; + if (!common_MyRecursiveShort_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyRecursiveShort related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyRecursiveShort; + ann_custom_MyRecursiveShort.reset(); + CompleteAliasBody body_MyRecursiveShort = TypeObjectUtils::build_complete_alias_body(common_MyRecursiveShort, + member_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort); + CompleteAliasType alias_type_MyRecursiveShort = TypeObjectUtils::build_complete_alias_type(alias_flags_MyRecursiveShort, + header_MyRecursiveShort, body_MyRecursiveShort); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyRecursiveShort, + type_name_MyRecursiveShort.to_string(), type_ids_MyRecursiveShort)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyRecursiveShort already registered in TypeObjectRegistry for a different type."); + } + } +} + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_alias_struct_type_identifier( + TypeIdentifierPair& type_ids_alias_struct) +{ + + ReturnCode_t return_code_alias_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_alias_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "alias_struct", type_ids_alias_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_struct) + { + StructTypeFlag struct_flags_alias_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_alias_struct = "alias_struct"; + eprosima::fastcdr::optional type_ann_builtin_alias_struct; + eprosima::fastcdr::optional ann_custom_alias_struct; + CompleteTypeDetail detail_alias_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_alias_struct, ann_custom_alias_struct, type_name_alias_struct.to_string()); + CompleteStructHeader header_alias_struct; + header_alias_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_alias_struct); + CompleteStructMemberSeq member_seq_alias_struct; + { + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyShort", type_ids_my_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + { + ::register_MyShort_type_identifier(type_ids_my_short); + } + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_short = 0x00000000; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; + ann_custom_alias_struct.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_alias_struct); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_short); + } + { + TypeIdentifierPair type_ids_my_long; + ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_long = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyLong", type_ids_my_long); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_long) + { + ::register_MyLong_type_identifier(type_ids_my_long); + } + StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_long = 0x00000001; + bool common_my_long_ec {false}; + CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; + if (!common_my_long_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_long member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_long = "my_long"; + eprosima::fastcdr::optional member_ann_builtin_my_long; + ann_custom_alias_struct.reset(); + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_alias_struct); + CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_long); + } + { + TypeIdentifierPair type_ids_my_recursive_short; + ReturnCode_t return_code_my_recursive_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_recursive_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyRecursiveShort", type_ids_my_recursive_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_short) + { + ::register_MyRecursiveShort_type_identifier(type_ids_my_recursive_short); + } + StructMemberFlag member_flags_my_recursive_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_recursive_short = 0x00000002; + bool common_my_recursive_short_ec {false}; + CommonStructMember common_my_recursive_short {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_short, member_flags_my_recursive_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_short, common_my_recursive_short_ec))}; + if (!common_my_recursive_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_recursive_short = "my_recursive_short"; + eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; + ann_custom_alias_struct.reset(); + CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_alias_struct); + CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); + TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_recursive_short); + } + CompleteStructType struct_type_alias_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_alias_struct, header_alias_struct, member_seq_alias_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_alias_struct, type_name_alias_struct.to_string(), type_ids_alias_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "alias_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..055027fe0a4 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp @@ -0,0 +1,98 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file alias_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register MyShort related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyShort_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +/** + * @brief Register MyLong related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyLong_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +/** + * @brief Register MyRecursiveShort related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +/** + * @brief Register alias_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_alias_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From 16e8b2ed615fd045f9a91e56fc3ac49f76ef6716 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 16:36:52 +0200 Subject: [PATCH 27/52] Support Annotation @key Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 10 +++++++--- .../xtypes/type_conversion/dyn_type_tree.ipp | 20 ++++++++++++++----- 2 files changed, 22 insertions(+), 8 deletions(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index be5e032aba1..f138eb1b9c3 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -26,6 +26,7 @@ #include #include #include +#include #include "utils/collections/TreeNode.hpp" @@ -42,16 +43,19 @@ struct TreeNodeType TreeNodeType( const std::string& member_name, const std::string& type_kind_name, - const DynamicType::_ref_type& dynamic_type) + const DynamicType::_ref_type& dynamic_type, + const bool is_key = false) : member_name(member_name) , type_kind_name(type_kind_name) , dynamic_type(dynamic_type) + , is_key(is_key) { } std::string member_name; std::string type_kind_name; DynamicType::_ref_type dynamic_type; + bool is_key; }; @@ -115,11 +119,11 @@ ReturnCode_t map_kind_to_str( * @brief Gathers the members of a DynamicType. * * @param dyn_type The DynamicType to gather the members from. - * @param result The vector of (name, type) to store the members. + * @param result The vector of (name, member_descriptor) to store the members. */ ReturnCode_t get_members_sorted( const DynamicType::_ref_type& dyn_type, - std::vector>& result) noexcept; + std::vector>& result) noexcept; /** * @brief Gathers the \c element_type of the DynamicType. diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index e7b0e2e7a07..3f88aebd611 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -54,7 +54,7 @@ ReturnCode_t dyn_type_to_tree( utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); // Get all members of this struct - std::vector> members_by_name; + std::vector> members_by_name; ret = get_members_sorted(type, members_by_name); if (ret != RETCODE_OK) @@ -64,14 +64,19 @@ ReturnCode_t dyn_type_to_tree( for (const auto& member : members_by_name) { + const auto& member_name = member.first; + const auto& member_descriptor = member.second; + utilities::collections::TreeNode child; - ret = dyn_type_to_tree(member.second, member.first, child); + ret = dyn_type_to_tree(member_descriptor->type(), member_name, child); if (ret != RETCODE_OK) { return ret; } + child.info.is_key = member_descriptor->is_key(); + // Add each member with its name as a new child in a branch (recursion) parent.add_branch(child); } @@ -412,7 +417,7 @@ ReturnCode_t map_kind_to_str( ReturnCode_t get_members_sorted( const DynamicType::_ref_type& dyn_type, - std::vector>& result) noexcept + std::vector>& result) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -436,9 +441,9 @@ ReturnCode_t get_members_sorted( const auto dyn_name = member.second->get_name(); result.emplace_back( - std::make_pair( + std::make_pair( dyn_name.to_string(), - std::move(member_descriptor->type()))); + std::move(member_descriptor))); } return ret; @@ -942,6 +947,11 @@ ReturnCode_t node_to_str( { node_str = TAB_SEPARATOR; + if (node.info.is_key) + { + node_str += "@key "; + } + if (node.info.dynamic_type->get_kind() == TK_ARRAY) { const auto dim_pos = node.info.type_kind_name.find("["); From eb8e73aad9e4de965489badc8dc845ae23100d75 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 24 Jun 2024 16:37:04 +0200 Subject: [PATCH 28/52] Tests - Annotation @key Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 10 +- .../type_conversion/types/idls/key_struct.idl | 6 + .../type_objects/key_struct/key_struct.hpp | 252 ++++++++++++++++++ .../key_struct/key_structCdrAux.hpp | 46 ++++ .../key_struct/key_structCdrAux.ipp | 138 ++++++++++ .../key_struct/key_structPubSubTypes.cxx | 229 ++++++++++++++++ .../key_struct/key_structPubSubTypes.h | 133 +++++++++ .../key_structTypeObjectSupport.cxx | 186 +++++++++++++ .../key_structTypeObjectSupport.hpp | 56 ++++ 10 files changed, 1059 insertions(+), 1 deletion(-) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index d7194e12a79..e1ddb057b8c 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -68,6 +68,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/alias_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/alias_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/key_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/key_struct.idl + COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynamicTypeSerializationTests.cpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index c91ba0cc044..8e6af185ccd 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -68,6 +68,9 @@ #include "type_objects/alias_struct/alias_struct.hpp" #include "type_objects/alias_struct/alias_structPubSubTypes.h" +#include "type_objects/key_struct/key_struct.hpp" +#include "type_objects/key_struct/key_structPubSubTypes.h" + namespace test { namespace SupportedTypes { @@ -86,6 +89,7 @@ const std::string MAP_STRUCT{"map_struct"}; const std::string BITSET_STRUCT{"bitset_struct"}; const std::string BITMASK_STRUCT{"bitmask_struct"}; const std::string ALIAS_STRUCT{"alias_struct"}; +const std::string KEY_STRUCT{"key_struct"}; } // namespace SupportedTypes @@ -103,7 +107,8 @@ const std::vector supported_types = { SupportedTypes::MAP_STRUCT, SupportedTypes::BITSET_STRUCT, SupportedTypes::BITMASK_STRUCT, - SupportedTypes::ALIAS_STRUCT + SupportedTypes::ALIAS_STRUCT, + SupportedTypes::KEY_STRUCT }; void register_dynamic_types() @@ -151,6 +156,9 @@ void register_dynamic_types() TypeSupport type_alias_struct(new alias_structPubSubType()); type_alias_struct->register_type_object_representation(); + + TypeSupport type_key_struct(new key_structPubSubType()); + type_key_struct->register_type_object_representation(); } } /* namespace test */ diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl new file mode 100644 index 00000000000..7137a0b6872 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl @@ -0,0 +1,6 @@ +struct key_struct +{ + short small_num; + @key long big_num; + @key unsigned long long huge_num; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp new file mode 100644 index 00000000000..5b03474991b --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp @@ -0,0 +1,252 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(KEY_STRUCT_SOURCE) +#define KEY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define KEY_STRUCT_DllAPI __declspec( dllimport ) +#endif // KEY_STRUCT_SOURCE +#else +#define KEY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define KEY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure key_struct defined by the user in the IDL file. + * @ingroup key_struct + */ +class key_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport key_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~key_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object key_struct that will be copied. + */ + eProsima_user_DllExport key_struct( + const key_struct& x) + { + m_small_num = x.m_small_num; + + m_big_num = x.m_big_num; + + m_huge_num = x.m_huge_num; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object key_struct that will be copied. + */ + eProsima_user_DllExport key_struct( + key_struct&& x) noexcept + { + m_small_num = x.m_small_num; + m_big_num = x.m_big_num; + m_huge_num = x.m_huge_num; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object key_struct that will be copied. + */ + eProsima_user_DllExport key_struct& operator =( + const key_struct& x) + { + + m_small_num = x.m_small_num; + + m_big_num = x.m_big_num; + + m_huge_num = x.m_huge_num; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object key_struct that will be copied. + */ + eProsima_user_DllExport key_struct& operator =( + key_struct&& x) noexcept + { + + m_small_num = x.m_small_num; + m_big_num = x.m_big_num; + m_huge_num = x.m_huge_num; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x key_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const key_struct& x) const + { + return (m_small_num == x.m_small_num && + m_big_num == x.m_big_num && + m_huge_num == x.m_huge_num); + } + + /*! + * @brief Comparison operator. + * @param x key_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const key_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member small_num + * @param _small_num New value for member small_num + */ + eProsima_user_DllExport void small_num( + int16_t _small_num) + { + m_small_num = _small_num; + } + + /*! + * @brief This function returns the value of member small_num + * @return Value of member small_num + */ + eProsima_user_DllExport int16_t small_num() const + { + return m_small_num; + } + + /*! + * @brief This function returns a reference to member small_num + * @return Reference to member small_num + */ + eProsima_user_DllExport int16_t& small_num() + { + return m_small_num; + } + + + /*! + * @brief This function sets a value in member big_num + * @param _big_num New value for member big_num + */ + eProsima_user_DllExport void big_num( + int32_t _big_num) + { + m_big_num = _big_num; + } + + /*! + * @brief This function returns the value of member big_num + * @return Value of member big_num + */ + eProsima_user_DllExport int32_t big_num() const + { + return m_big_num; + } + + /*! + * @brief This function returns a reference to member big_num + * @return Reference to member big_num + */ + eProsima_user_DllExport int32_t& big_num() + { + return m_big_num; + } + + + /*! + * @brief This function sets a value in member huge_num + * @param _huge_num New value for member huge_num + */ + eProsima_user_DllExport void huge_num( + uint64_t _huge_num) + { + m_huge_num = _huge_num; + } + + /*! + * @brief This function returns the value of member huge_num + * @return Value of member huge_num + */ + eProsima_user_DllExport uint64_t huge_num() const + { + return m_huge_num; + } + + /*! + * @brief This function returns a reference to member huge_num + * @return Reference to member huge_num + */ + eProsima_user_DllExport uint64_t& huge_num() + { + return m_huge_num; + } + + + +private: + + int16_t m_small_num{0}; + int32_t m_big_num{0}; + uint64_t m_huge_num{0}; + +}; + +#endif // _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp new file mode 100644 index 00000000000..9974cd2e26e --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ + +#include "key_struct.hpp" + +constexpr uint32_t key_struct_max_cdr_typesize {24UL}; +constexpr uint32_t key_struct_max_key_cdr_typesize {16UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const key_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp new file mode 100644 index 00000000000..15330eb2b1b --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp @@ -0,0 +1,138 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ + +#include "key_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const key_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.small_num(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.big_num(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.huge_num(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const key_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.small_num() + << eprosima::fastcdr::MemberId(1) << data.big_num() + << eprosima::fastcdr::MemberId(2) << data.huge_num() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + key_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.small_num(); + break; + + case 1: + dcdr >> data.big_num(); + break; + + case 2: + dcdr >> data.huge_num(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const key_struct& data) +{ + static_cast(scdr); + static_cast(data); + scdr << data.big_num(); + + scdr << data.huge_num(); + +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx new file mode 100644 index 00000000000..4adcc1d420f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "key_structPubSubTypes.h" + +#include +#include + +#include "key_structCdrAux.hpp" +#include "key_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +key_structPubSubType::key_structPubSubType() +{ + setName("key_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(key_struct::getMaxCdrSerializedSize()); +#else + key_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = true; + uint32_t keyLength = key_struct_max_key_cdr_typesize > 16 ? key_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +key_structPubSubType::~key_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool key_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + key_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool key_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + key_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function key_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* key_structPubSubType::createData() +{ + return reinterpret_cast(new key_struct()); +} + +void key_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool key_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + key_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + key_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || key_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void key_structPubSubType::register_type_object_representation() +{ + register_key_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "key_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h new file mode 100644 index 00000000000..59f101ea154 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "key_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated key_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type key_struct defined by the user in the IDL file. + * @ingroup key_struct + */ +class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef key_struct type; + + eProsima_user_DllExport key_structPubSubType(); + + eProsima_user_DllExport ~key_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..b3b72e9fc7f --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx @@ -0,0 +1,186 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "key_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "key_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_key_struct_type_identifier( + TypeIdentifierPair& type_ids_key_struct) +{ + + ReturnCode_t return_code_key_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_key_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "key_struct", type_ids_key_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_key_struct) + { + StructTypeFlag struct_flags_key_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_key_struct = "key_struct"; + eprosima::fastcdr::optional type_ann_builtin_key_struct; + eprosima::fastcdr::optional ann_custom_key_struct; + CompleteTypeDetail detail_key_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_key_struct, ann_custom_key_struct, type_name_key_struct.to_string()); + CompleteStructHeader header_key_struct; + header_key_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_key_struct); + CompleteStructMemberSeq member_seq_key_struct; + { + TypeIdentifierPair type_ids_small_num; + ReturnCode_t return_code_small_num {eprosima::fastdds::dds::RETCODE_OK}; + return_code_small_num = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_small_num); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_small_num) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "small_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_small_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_small_num = 0x00000000; + bool common_small_num_ec {false}; + CommonStructMember common_small_num {TypeObjectUtils::build_common_struct_member(member_id_small_num, member_flags_small_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_small_num, common_small_num_ec))}; + if (!common_small_num_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure small_num member TypeIdentifier inconsistent."); + return; + } + MemberName name_small_num = "small_num"; + eprosima::fastcdr::optional member_ann_builtin_small_num; + ann_custom_key_struct.reset(); + CompleteMemberDetail detail_small_num = TypeObjectUtils::build_complete_member_detail(name_small_num, member_ann_builtin_small_num, ann_custom_key_struct); + CompleteStructMember member_small_num = TypeObjectUtils::build_complete_struct_member(common_small_num, detail_small_num); + TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_small_num); + } + { + TypeIdentifierPair type_ids_big_num; + ReturnCode_t return_code_big_num {eprosima::fastdds::dds::RETCODE_OK}; + return_code_big_num = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_big_num); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_big_num) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "big_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_big_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_big_num = 0x00000001; + bool common_big_num_ec {false}; + CommonStructMember common_big_num {TypeObjectUtils::build_common_struct_member(member_id_big_num, member_flags_big_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_big_num, common_big_num_ec))}; + if (!common_big_num_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure big_num member TypeIdentifier inconsistent."); + return; + } + MemberName name_big_num = "big_num"; + eprosima::fastcdr::optional member_ann_builtin_big_num; + ann_custom_key_struct.reset(); + AppliedAnnotationSeq tmp_ann_custom_big_num; + eprosima::fastcdr::optional unit_big_num; + eprosima::fastcdr::optional min_big_num; + eprosima::fastcdr::optional max_big_num; + eprosima::fastcdr::optional hash_id_big_num; + if (unit_big_num.has_value() || min_big_num.has_value() || max_big_num.has_value() || hash_id_big_num.has_value()) + { + member_ann_builtin_big_num = TypeObjectUtils::build_applied_builtin_member_annotations(unit_big_num, min_big_num, max_big_num, hash_id_big_num); + } + if (!tmp_ann_custom_big_num.empty()) + { + ann_custom_key_struct = tmp_ann_custom_big_num; + } + CompleteMemberDetail detail_big_num = TypeObjectUtils::build_complete_member_detail(name_big_num, member_ann_builtin_big_num, ann_custom_key_struct); + CompleteStructMember member_big_num = TypeObjectUtils::build_complete_struct_member(common_big_num, detail_big_num); + TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_big_num); + } + { + TypeIdentifierPair type_ids_huge_num; + ReturnCode_t return_code_huge_num {eprosima::fastdds::dds::RETCODE_OK}; + return_code_huge_num = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint64_t", type_ids_huge_num); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_huge_num) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "huge_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_huge_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_huge_num = 0x00000002; + bool common_huge_num_ec {false}; + CommonStructMember common_huge_num {TypeObjectUtils::build_common_struct_member(member_id_huge_num, member_flags_huge_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_huge_num, common_huge_num_ec))}; + if (!common_huge_num_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure huge_num member TypeIdentifier inconsistent."); + return; + } + MemberName name_huge_num = "huge_num"; + eprosima::fastcdr::optional member_ann_builtin_huge_num; + ann_custom_key_struct.reset(); + AppliedAnnotationSeq tmp_ann_custom_huge_num; + eprosima::fastcdr::optional unit_huge_num; + eprosima::fastcdr::optional min_huge_num; + eprosima::fastcdr::optional max_huge_num; + eprosima::fastcdr::optional hash_id_huge_num; + if (unit_huge_num.has_value() || min_huge_num.has_value() || max_huge_num.has_value() || hash_id_huge_num.has_value()) + { + member_ann_builtin_huge_num = TypeObjectUtils::build_applied_builtin_member_annotations(unit_huge_num, min_huge_num, max_huge_num, hash_id_huge_num); + } + if (!tmp_ann_custom_huge_num.empty()) + { + ann_custom_key_struct = tmp_ann_custom_huge_num; + } + CompleteMemberDetail detail_huge_num = TypeObjectUtils::build_complete_member_detail(name_huge_num, member_ann_builtin_huge_num, ann_custom_key_struct); + CompleteStructMember member_huge_num = TypeObjectUtils::build_complete_struct_member(common_huge_num, detail_huge_num); + TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_huge_num); + } + CompleteStructType struct_type_key_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_key_struct, header_key_struct, member_seq_key_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_key_struct, type_name_key_struct.to_string(), type_ids_key_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "key_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..e920230d5ff --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register key_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_key_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From da9068f9b502a69fbace8d85ed0948032138f439 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 08:22:20 +0200 Subject: [PATCH 29/52] Rearrange & sort methods Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 64 +-- .../xtypes/type_conversion/dyn_type_tree.ipp | 402 +++++++++--------- .../dds/xtypes/type_conversion/CMakeLists.txt | 48 +-- .../type_conversion/types/all_types.hpp | 146 +++---- 4 files changed, 327 insertions(+), 333 deletions(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index f138eb1b9c3..d9110d599a2 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -81,7 +81,7 @@ ReturnCode_t dyn_type_to_tree( * @param dyn_type The DynamicType to convert. * @param type_str The string representation of the DynamicType. */ -ReturnCode_t dyn_type_to_str( +ReturnCode_t type_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& type_str) noexcept; @@ -96,24 +96,24 @@ ReturnCode_t array_kind_to_str( std::string& array_str) noexcept; /** - * @brief Converts a DynamicType of \c TK_SEQUENCE kind to a string. + * @brief Converts a DynamicType of \c TK_MAP kind to a string. * * @param dyn_type The DynamicType to convert. - * @param sequence_str The string representation of the DynamicType. + * @param map_str The string representation of the DynamicType. */ -ReturnCode_t sequence_kind_to_str( +ReturnCode_t map_kind_to_str( const DynamicType::_ref_type& dyn_type, - std::string& sequence_str) noexcept; + std::string& map_str) noexcept; /** - * @brief Converts a DynamicType of \c TK_MAP kind to a string. + * @brief Converts a DynamicType of \c TK_SEQUENCE kind to a string. * * @param dyn_type The DynamicType to convert. - * @param map_str The string representation of the DynamicType. + * @param sequence_str The string representation of the DynamicType. */ -ReturnCode_t map_kind_to_str( +ReturnCode_t sequence_kind_to_str( const DynamicType::_ref_type& dyn_type, - std::string& map_str) noexcept; + std::string& sequence_str) noexcept; /** * @brief Gathers the members of a DynamicType. @@ -161,64 +161,64 @@ ReturnCode_t dyn_type_tree_to_idl( std::string& dyn_type_str) noexcept; /** - * @brief Converts a tree with a \c TK_STRUCTURE root to an IDL string. + * @brief Converts a tree with a \c TK_ALIAS root to an IDL string. * * @param node The root node of the tree. - * @param struct_str The string representation of the tree. + * @param alias_str The string representation of the tree. */ -ReturnCode_t struct_to_str( +ReturnCode_t alias_to_str( const utilities::collections::TreeNode& node, - std::string& struct_str) noexcept; + std::string& alias_str) noexcept; /** - * @brief Converts a tree with a \c TK_ENUM root to an IDL string. + * @brief Converts a tree with a \c TK_BITMASK root to an IDL string. * * @param node The root node of the tree. - * @param enum_str The string representation of the tree. + * @param union_str The string representation of the tree. */ -ReturnCode_t enum_to_str( +ReturnCode_t bitmask_to_str( const utilities::collections::TreeNode& node, - std::string& enum_str) noexcept; + std::string& bitset_str) noexcept; /** - * @brief Converts a tree with a \c TK_UNION root to an IDL string. + * @brief Converts a tree with a \c TK_BITSET root to an IDL string. * * @param node The root node of the tree. * @param union_str The string representation of the tree. */ -ReturnCode_t union_to_str( +ReturnCode_t bitset_to_str( const utilities::collections::TreeNode& node, - std::string& union_str) noexcept; + std::string& bitset_str) noexcept; /** - * @brief Converts a tree with a \c TK_BITSET root to an IDL string. + * @brief Converts a tree with a \c TK_ENUM root to an IDL string. * * @param node The root node of the tree. - * @param union_str The string representation of the tree. + * @param enum_str The string representation of the tree. */ -ReturnCode_t bitset_to_str( +ReturnCode_t enum_to_str( const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept; + std::string& enum_str) noexcept; /** - * @brief Converts a tree with a \c TK_BITMASK root to an IDL string. + * @brief Converts a tree with a \c TK_STRUCTURE root to an IDL string. * * @param node The root node of the tree. - * @param union_str The string representation of the tree. + * @param struct_str The string representation of the tree. */ -ReturnCode_t bitmask_to_str( +ReturnCode_t struct_to_str( const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept; + std::string& struct_str) noexcept; /** - * @brief Converts a tree with a \c TK_ALIAS root to an IDL string. + * @brief Converts a tree with a \c TK_UNION root to an IDL string. * * @param node The root node of the tree. - * @param alias_str The string representation of the tree. + * @param union_str The string representation of the tree. */ -ReturnCode_t alias_to_str( +ReturnCode_t union_to_str( const utilities::collections::TreeNode& node, - std::string& alias_str) noexcept; + std::string& union_str) noexcept; /** * @brief Converts a simple tree to an IDL string. diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index 3f88aebd611..893d211ee1e 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -98,7 +98,7 @@ ReturnCode_t dyn_type_to_tree( } std::string internal_str; - ret = dyn_type_to_str(type, internal_str); + ret = type_kind_to_str(type, internal_str); if (ret != RETCODE_OK) { @@ -123,7 +123,7 @@ ReturnCode_t dyn_type_to_tree( default: { std::string type_str; - ret = dyn_type_to_str(type, type_str); + ret = type_kind_to_str(type, type_str); if (ret != RETCODE_OK) { @@ -138,7 +138,7 @@ ReturnCode_t dyn_type_to_tree( return ret; } -ReturnCode_t dyn_type_to_str( +ReturnCode_t type_kind_to_str( const DynamicType::_ref_type& dyn_type, std::string& type_str) noexcept { @@ -291,7 +291,7 @@ ReturnCode_t array_kind_to_str( return ret; } - ret = dyn_type_to_str(internal_type, array_str); + ret = type_kind_to_str(internal_type, array_str); if (ret != RETCODE_OK) { @@ -316,101 +316,101 @@ ReturnCode_t array_kind_to_str( return ret; } -ReturnCode_t sequence_kind_to_str( +ReturnCode_t map_kind_to_str( const DynamicType::_ref_type& dyn_type, - std::string& sequence_str) noexcept + std::string& map_str) noexcept { - if (dyn_type->get_kind() != TK_SEQUENCE) + if (dyn_type->get_kind() != TK_MAP) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a sequence."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a map."); return RETCODE_BAD_PARAMETER; } ReturnCode_t ret = RETCODE_OK; - DynamicType::_ref_type internal_type; - ret = container_internal_type(dyn_type, internal_type); + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = dyn_type->get_descriptor(type_descriptor); if (ret != RETCODE_OK) { return ret; } - ret = dyn_type_to_str(internal_type, sequence_str); + std::string key_str; + const auto key_type = type_descriptor->key_element_type(); + ret = type_kind_to_str(key_type, key_str); if (ret != RETCODE_OK) { return ret; } - sequence_str = "sequence<" + sequence_str; - - BoundSeq bounds; - ret = container_size(dyn_type, bounds); + std::string value_str; + const auto value_type = type_descriptor->element_type(); + ret = type_kind_to_str(value_type, value_str); if (ret != RETCODE_OK) { return ret; } - for (const auto& bound : bounds) - { - const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); + std::stringstream ss; - if (bound != UNBOUNDED) - { - sequence_str += ", " + std::to_string(bound); - } - } + ss << "map<" << key_str << ", " << value_str << ">"; - sequence_str += ">"; + map_str = ss.str(); return ret; } -ReturnCode_t map_kind_to_str( +ReturnCode_t sequence_kind_to_str( const DynamicType::_ref_type& dyn_type, - std::string& map_str) noexcept + std::string& sequence_str) noexcept { - if (dyn_type->get_kind() != TK_MAP) + if (dyn_type->get_kind() != TK_SEQUENCE) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a map."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a sequence."); return RETCODE_BAD_PARAMETER; } ReturnCode_t ret = RETCODE_OK; - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = dyn_type->get_descriptor(type_descriptor); + DynamicType::_ref_type internal_type; + ret = container_internal_type(dyn_type, internal_type); if (ret != RETCODE_OK) { return ret; } - std::string key_str; - const auto key_type = type_descriptor->key_element_type(); - ret = dyn_type_to_str(key_type, key_str); + ret = type_kind_to_str(internal_type, sequence_str); if (ret != RETCODE_OK) { return ret; } - std::string value_str; - const auto value_type = type_descriptor->element_type(); - ret = dyn_type_to_str(value_type, value_str); + sequence_str = "sequence<" + sequence_str; + + BoundSeq bounds; + ret = container_size(dyn_type, bounds); if (ret != RETCODE_OK) { return ret; } - std::stringstream ss; + for (const auto& bound : bounds) + { + const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); - ss << "map<" << key_str << ", " << value_str << ">"; + if (bound != UNBOUNDED) + { + sequence_str += ", " + std::to_string(bound); + } + } - map_str = ss.str(); + sequence_str += ">"; return ret; } @@ -515,34 +515,34 @@ ReturnCode_t dyn_type_tree_to_idl( switch (kind) { - case TK_STRUCTURE: + case TK_ALIAS: { - ret = struct_to_str(node, kind_str); + ret = alias_to_str(node, kind_str); break; } - case TK_ENUM: + case TK_BITMASK: { - ret = enum_to_str(node, kind_str); + ret = bitmask_to_str(node, kind_str); break; } - case TK_UNION: + case TK_BITSET: { - ret = union_to_str(node, kind_str); + ret = bitset_to_str(node, kind_str); break; } - case TK_BITSET: + case TK_ENUM: { - ret = bitset_to_str(node, kind_str); + ret = enum_to_str(node, kind_str); break; } - case TK_BITMASK: + case TK_STRUCTURE: { - ret = bitmask_to_str(node, kind_str); + ret = struct_to_str(node, kind_str); break; } - case TK_ALIAS: + case TK_UNION: { - ret = alias_to_str(node, kind_str); + ret = union_to_str(node, kind_str); break; } default: @@ -575,81 +575,49 @@ ReturnCode_t dyn_type_tree_to_idl( return ret; } -ReturnCode_t struct_to_str( +ReturnCode_t alias_to_str( const utilities::collections::TreeNode& node, - std::string& struct_str) noexcept + std::string& alias_str) noexcept { - if (node.info.dynamic_type->get_kind() != TK_STRUCTURE) + if (node.info.dynamic_type->get_kind() != TK_ALIAS) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a struct."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an alias."); return RETCODE_BAD_PARAMETER; } - // Add types name - struct_str = "struct " + node.info.type_kind_name + TYPE_OPENING; - - // Add struct attributes - for (auto const& child : node.branches()) - { - std::string child_str; - node_to_str(child.info, child_str); - - struct_str += child_str + ";\n"; - } - - // Close definition - struct_str += TYPE_CLOSURE; + ReturnCode_t ret = RETCODE_OK; - return RETCODE_OK; -} + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); -ReturnCode_t enum_to_str( - const utilities::collections::TreeNode& node, - std::string& enum_str) noexcept -{ - if (node.info.dynamic_type->get_kind() != TK_ENUM) + if (ret != RETCODE_OK) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an enum."); - return RETCODE_BAD_PARAMETER; + return ret; } - ReturnCode_t ret = RETCODE_OK; - - enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; + // Find the base type of the alias + std::string base_type_kind_str; + ret = type_kind_to_str(type_descriptor->base_type(), base_type_kind_str); - for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) + if (ret != RETCODE_OK) { - traits::ref_type member; - ret = node.info.dynamic_type->get_member_by_index(member, index); - - if (ret != RETCODE_OK) - { - return ret; - } - - if (index != 0) - { - enum_str += ",\n"; - enum_str += TAB_SEPARATOR; - } - - enum_str += member->get_name().to_string(); + return ret; } - // Close definition - enum_str += "\n"; - enum_str += TYPE_CLOSURE; + alias_str = "typedef "; + alias_str += base_type_kind_str + " "; + alias_str += type_descriptor->name().to_string() + ";\n"; return ret; } -ReturnCode_t union_to_str( +ReturnCode_t bitmask_to_str( const utilities::collections::TreeNode& node, - std::string& union_str) noexcept + std::string& bitset_str) noexcept { - if (node.info.dynamic_type->get_kind() != TK_UNION) + if (node.info.dynamic_type->get_kind() != TK_BITMASK) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a union."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitmask."); return RETCODE_BAD_PARAMETER; } @@ -663,66 +631,63 @@ ReturnCode_t union_to_str( return ret; } - std::string discriminant_type_str; - ret = dyn_type_to_str(type_descriptor->discriminator_type(), discriminant_type_str); + if (type_descriptor->bound().size() != 1) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Bitmask type must have exactly one bound."); + return RETCODE_BAD_PARAMETER; + } - if (ret != RETCODE_OK) + // Annotation with the bitmask size + static constexpr std::uint32_t DEFAULT_BITMASK_SIZE = 32; + const auto bitmask_size = type_descriptor->bound()[0]; + + if (bitmask_size != DEFAULT_BITMASK_SIZE) { - return ret; + bitset_str = "@bit_bound(" + std::to_string(bitmask_size) + ")\n"; } - union_str = "union " + node.info.type_kind_name + " switch (" + discriminant_type_str + ")" + TYPE_OPENING; + bitset_str += "bitmask " + node.info.type_kind_name + TYPE_OPENING; - for (std::uint32_t index = 1; index < node.info.dynamic_type->get_member_count(); index++) + const auto member_count = node.info.dynamic_type->get_member_count(); + + std::uint32_t pos = 0; + + for (std::uint32_t index = 0; index < member_count; index++) { traits::ref_type member; ret = node.info.dynamic_type->get_member_by_index(member, index); - MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member->get_descriptor(member_descriptor); - if (ret != RETCODE_OK) { return ret; } - const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration - bool first_iter = true; - - for (const auto& label : labels) - { - if (first_iter) - { - union_str += TAB_SEPARATOR; - } - else - { - union_str += " "; - } + bitset_str += TAB_SEPARATOR; - first_iter = false; + // Annotation with the position + const auto id = member->get_id(); - union_str += "case " + std::to_string(label) + ":"; + if (id != pos) + { + bitset_str += "@position(" + std::to_string(id) + ") "; } - std::string member_str; - ret = dyn_type_to_str(member_descriptor->type(), member_str); + bitset_str += member->get_name().to_string(); - if (ret != RETCODE_OK) + // Add comma if not last member + if (index < member_count - 1) { - return ret; + bitset_str += ","; } - union_str += "\n"; - union_str += TAB_SEPARATOR; - union_str += TAB_SEPARATOR; - union_str += member_str + " "; - union_str += member->get_name().to_string(); - union_str += ";\n"; + bitset_str += "\n"; + + // The position is always sequential + pos = id + 1; } // Close definition - union_str += TYPE_CLOSURE; + bitset_str += TYPE_CLOSURE; return ret; } @@ -805,7 +770,7 @@ ReturnCode_t bitset_to_str( { // The type of the bitfield is not the default type. Write it. std::string type_str; - dyn_type_to_str(member_descriptor->type(), type_str); + type_kind_to_str(member_descriptor->type(), type_str); bitset_str += ", "; bitset_str += type_str; @@ -824,48 +789,21 @@ ReturnCode_t bitset_to_str( return ret; } -ReturnCode_t bitmask_to_str( +ReturnCode_t enum_to_str( const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept + std::string& enum_str) noexcept { - if (node.info.dynamic_type->get_kind() != TK_BITMASK) + if (node.info.dynamic_type->get_kind() != TK_ENUM) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitmask."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an enum."); return RETCODE_BAD_PARAMETER; } ReturnCode_t ret = RETCODE_OK; - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = node.info.dynamic_type->get_descriptor(type_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - if (type_descriptor->bound().size() != 1) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Bitmask type must have exactly one bound."); - return RETCODE_BAD_PARAMETER; - } - - // Annotation with the bitmask size - static constexpr std::uint32_t DEFAULT_BITMASK_SIZE = 32; - const auto bitmask_size = type_descriptor->bound()[0]; - - if (bitmask_size != DEFAULT_BITMASK_SIZE) - { - bitset_str = "@bit_bound(" + std::to_string(bitmask_size) + ")\n"; - } - - bitset_str += "bitmask " + node.info.type_kind_name + TYPE_OPENING; - - const auto member_count = node.info.dynamic_type->get_member_count(); - - std::uint32_t pos = 0; + enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; - for (std::uint32_t index = 0; index < member_count; index++) + for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) { traits::ref_type member; ret = node.info.dynamic_type->get_member_by_index(member, index); @@ -875,43 +813,57 @@ ReturnCode_t bitmask_to_str( return ret; } - bitset_str += TAB_SEPARATOR; - - // Annotation with the position - const auto id = member->get_id(); - - if (id != pos) + if (index != 0) { - bitset_str += "@position(" + std::to_string(id) + ") "; + enum_str += ",\n"; + enum_str += TAB_SEPARATOR; } - bitset_str += member->get_name().to_string(); + enum_str += member->get_name().to_string(); + } - // Add comma if not last member - if (index < member_count - 1) - { - bitset_str += ","; - } + // Close definition + enum_str += "\n"; + enum_str += TYPE_CLOSURE; - bitset_str += "\n"; + return ret; +} - // The position is always sequential - pos = id + 1; +ReturnCode_t struct_to_str( + const utilities::collections::TreeNode& node, + std::string& struct_str) noexcept +{ + if (node.info.dynamic_type->get_kind() != TK_STRUCTURE) + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a struct."); + return RETCODE_BAD_PARAMETER; + } + + // Add types name + struct_str = "struct " + node.info.type_kind_name + TYPE_OPENING; + + // Add struct attributes + for (auto const& child : node.branches()) + { + std::string child_str; + node_to_str(child.info, child_str); + + struct_str += child_str + ";\n"; } // Close definition - bitset_str += TYPE_CLOSURE; + struct_str += TYPE_CLOSURE; - return ret; + return RETCODE_OK; } -ReturnCode_t alias_to_str( +ReturnCode_t union_to_str( const utilities::collections::TreeNode& node, - std::string& alias_str) noexcept + std::string& union_str) noexcept { - if (node.info.dynamic_type->get_kind() != TK_ALIAS) + if (node.info.dynamic_type->get_kind() != TK_UNION) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an alias."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a union."); return RETCODE_BAD_PARAMETER; } @@ -925,18 +877,66 @@ ReturnCode_t alias_to_str( return ret; } - // Find the base type of the alias - std::string base_type_kind_str; - ret = dyn_type_to_str(type_descriptor->base_type(), base_type_kind_str); + std::string discriminant_type_str; + ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); if (ret != RETCODE_OK) { return ret; } - alias_str = "typedef "; - alias_str += base_type_kind_str + " "; - alias_str += type_descriptor->name().to_string() + ";\n"; + union_str = "union " + node.info.type_kind_name + " switch (" + discriminant_type_str + ")" + TYPE_OPENING; + + for (std::uint32_t index = 1; index < node.info.dynamic_type->get_member_count(); index++) + { + traits::ref_type member; + ret = node.info.dynamic_type->get_member_by_index(member, index); + + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member->get_descriptor(member_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration + bool first_iter = true; + + for (const auto& label : labels) + { + if (first_iter) + { + union_str += TAB_SEPARATOR; + } + else + { + union_str += " "; + } + + first_iter = false; + + union_str += "case " + std::to_string(label) + ":"; + } + + std::string member_str; + ret = type_kind_to_str(member_descriptor->type(), member_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + union_str += "\n"; + union_str += TAB_SEPARATOR; + union_str += TAB_SEPARATOR; + union_str += member_str + " "; + union_str += member->get_name().to_string(); + union_str += ";\n"; + } + + // Close definition + union_str += TYPE_CLOSURE; return ret; } diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index e1ddb057b8c..1ffdcf884a4 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -13,32 +13,32 @@ # limitations under the License. configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/hello_world.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/hello_world.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/alias_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/alias_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/arrays_and_sequences.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/arrays_and_sequences.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/char_sequence.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/char_sequence.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_array_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_array_struct.idl COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_array_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_array_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitmask_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitmask_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/float_bounded_sequence.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/float_bounded_sequence.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitset_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitset_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/arrays_and_sequences.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/arrays_and_sequences.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/char_sequence.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/char_sequence.idl COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/complex_nested_arrays.idl @@ -49,28 +49,28 @@ configure_file( ${CMAKE_CURRENT_BINARY_DIR}/types/idls/enum_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/union_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/union_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/float_bounded_sequence.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/float_bounded_sequence.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/hello_world.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/hello_world.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitset_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitset_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/key_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/key_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitmask_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitmask_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/alias_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/alias_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/key_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/key_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/union_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/union_struct.idl COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index 8e6af185ccd..af93baadc71 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -16,36 +16,30 @@ * @file all_types.hpp */ -/* - * USEFUL COMMAND - * - * for TYPE in hello_world numeric_array char_sequence basic_struct basic_array_struct float_bounded_sequence arrays_and_sequences complex_nested_arrays; do ${FASTDDSGEN_WS}/scripts/fastddsgen -replace -d ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/type_objects/ -typeobject -cs ${WS}/src/recorder/ddsrecorder/test/unittest/dynamic_types/types/idls/${TYPE}.idl; done - */ - #include #include -#include "type_objects/hello_world/hello_world.hpp" -#include "type_objects/hello_world/hello_worldPubSubTypes.h" +#include "type_objects/alias_struct/alias_struct.hpp" +#include "type_objects/alias_struct/alias_structPubSubTypes.h" -#include "type_objects/numeric_array/numeric_array.hpp" -#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" +#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" +#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" -#include "type_objects/char_sequence/char_sequence.hpp" -#include "type_objects/char_sequence/char_sequencePubSubTypes.h" +#include "type_objects/basic_array_struct/basic_array_struct.hpp" +#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" #include "type_objects/basic_struct/basic_struct.hpp" #include "type_objects/basic_struct/basic_structPubSubTypes.h" -#include "type_objects/basic_array_struct/basic_array_struct.hpp" -#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" +#include "type_objects/bitmask_struct/bitmask_struct.hpp" +#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.h" -#include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" -#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" +#include "type_objects/bitset_struct/bitset_struct.hpp" +#include "type_objects/bitset_struct/bitset_structPubSubTypes.h" -#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" -#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" +#include "type_objects/char_sequence/char_sequence.hpp" +#include "type_objects/char_sequence/char_sequencePubSubTypes.h" #include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" #include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h" @@ -53,88 +47,88 @@ #include "type_objects/enum_struct/enum_struct.hpp" #include "type_objects/enum_struct/enum_structPubSubTypes.h" -#include "type_objects/union_struct/union_struct.hpp" -#include "type_objects/union_struct/union_structPubSubTypes.h" +#include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" +#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" -#include "type_objects/map_struct/map_struct.hpp" -#include "type_objects/map_struct/map_structPubSubTypes.h" +#include "type_objects/hello_world/hello_world.hpp" +#include "type_objects/hello_world/hello_worldPubSubTypes.h" -#include "type_objects/bitset_struct/bitset_struct.hpp" -#include "type_objects/bitset_struct/bitset_structPubSubTypes.h" +#include "type_objects/key_struct/key_struct.hpp" +#include "type_objects/key_struct/key_structPubSubTypes.h" -#include "type_objects/bitmask_struct/bitmask_struct.hpp" -#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.h" +#include "type_objects/map_struct/map_struct.hpp" +#include "type_objects/map_struct/map_structPubSubTypes.h" -#include "type_objects/alias_struct/alias_struct.hpp" -#include "type_objects/alias_struct/alias_structPubSubTypes.h" +#include "type_objects/numeric_array/numeric_array.hpp" +#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" -#include "type_objects/key_struct/key_struct.hpp" -#include "type_objects/key_struct/key_structPubSubTypes.h" +#include "type_objects/union_struct/union_struct.hpp" +#include "type_objects/union_struct/union_structPubSubTypes.h" namespace test { namespace SupportedTypes { -const std::string HELLO_WORLD{"hello_world"}; -const std::string NUMERIC_ARRAY{"numeric_array"}; -const std::string CHAR_SEQUENCE{"char_sequence"}; -const std::string BASIC_STRUCT{"basic_struct"}; -const std::string BASIC_ARRAY_STRUCT{"basic_array_struct"}; -const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; +const std::string ALIAS_STRUCT{"alias_struct"}; const std::string ARRAYS_AND_SEQUENCES{"arrays_and_sequences"}; +const std::string BASIC_ARRAY_STRUCT{"basic_array_struct"}; +const std::string BASIC_STRUCT{"basic_struct"}; +const std::string BITMASK_STRUCT{"bitmask_struct"}; +const std::string BITSET_STRUCT{"bitset_struct"}; +const std::string CHAR_SEQUENCE{"char_sequence"}; const std::string COMPLEX_NESTED_ARRAYS{"complex_nested_arrays"}; const std::string ENUM_STRUCT{"enum_struct"}; -const std::string UNION_STRUCT{"union_struct"}; -const std::string MAP_STRUCT{"map_struct"}; -const std::string BITSET_STRUCT{"bitset_struct"}; -const std::string BITMASK_STRUCT{"bitmask_struct"}; -const std::string ALIAS_STRUCT{"alias_struct"}; +const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; +const std::string HELLO_WORLD{"hello_world"}; const std::string KEY_STRUCT{"key_struct"}; +const std::string MAP_STRUCT{"map_struct"}; +const std::string NUMERIC_ARRAY{"numeric_array"}; +const std::string UNION_STRUCT{"union_struct"}; } // namespace SupportedTypes const std::vector supported_types = { - SupportedTypes::HELLO_WORLD, - SupportedTypes::NUMERIC_ARRAY, - SupportedTypes::CHAR_SEQUENCE, - SupportedTypes::BASIC_STRUCT, - SupportedTypes::BASIC_ARRAY_STRUCT, - SupportedTypes::FLOAT_BOUNDED_SEQUENCE, + SupportedTypes::ALIAS_STRUCT, SupportedTypes::ARRAYS_AND_SEQUENCES, + SupportedTypes::BASIC_ARRAY_STRUCT, + SupportedTypes::BASIC_STRUCT, + SupportedTypes::BITMASK_STRUCT, + SupportedTypes::BITSET_STRUCT, + SupportedTypes::CHAR_SEQUENCE, SupportedTypes::COMPLEX_NESTED_ARRAYS, SupportedTypes::ENUM_STRUCT, - SupportedTypes::UNION_STRUCT, + SupportedTypes::FLOAT_BOUNDED_SEQUENCE, + SupportedTypes::HELLO_WORLD, + SupportedTypes::KEY_STRUCT, SupportedTypes::MAP_STRUCT, - SupportedTypes::BITSET_STRUCT, - SupportedTypes::BITMASK_STRUCT, - SupportedTypes::ALIAS_STRUCT, - SupportedTypes::KEY_STRUCT + SupportedTypes::NUMERIC_ARRAY, + SupportedTypes::UNION_STRUCT }; void register_dynamic_types() { using namespace eprosima::fastdds::dds; - TypeSupport type_hello_world(new hello_worldPubSubType()); - type_hello_world->register_type_object_representation(); + TypeSupport type_alias_struct(new alias_structPubSubType()); + type_alias_struct->register_type_object_representation(); - TypeSupport type_numeric_array(new numeric_arrayPubSubType()); - type_numeric_array->register_type_object_representation(); + TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); + type_arrays_and_sequences->register_type_object_representation(); - TypeSupport type_char_sequence(new char_sequencePubSubType()); - type_char_sequence->register_type_object_representation(); + TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); + type_basic_array_struct->register_type_object_representation(); TypeSupport type_basic_struct(new basic_structPubSubType()); type_basic_struct->register_type_object_representation(); - TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); - type_basic_array_struct->register_type_object_representation(); + TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); + type_bitmask_struct->register_type_object_representation(); - TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); - type_float_bounded_sequence->register_type_object_representation(); + TypeSupport type_bitset_struct(new bitset_structPubSubType()); + type_bitset_struct->register_type_object_representation(); - TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); - type_arrays_and_sequences->register_type_object_representation(); + TypeSupport type_char_sequence(new char_sequencePubSubType()); + type_char_sequence->register_type_object_representation(); TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); type_complex_nested_arrays->register_type_object_representation(); @@ -142,23 +136,23 @@ void register_dynamic_types() TypeSupport type_enum_struct(new enum_structPubSubType()); type_enum_struct->register_type_object_representation(); - TypeSupport type_union_struct(new union_structPubSubType()); - type_union_struct->register_type_object_representation(); + TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); + type_float_bounded_sequence->register_type_object_representation(); - TypeSupport type_map_struct(new map_structPubSubType()); - type_map_struct->register_type_object_representation(); + TypeSupport type_hello_world(new hello_worldPubSubType()); + type_hello_world->register_type_object_representation(); - TypeSupport type_bitset_struct(new bitset_structPubSubType()); - type_bitset_struct->register_type_object_representation(); + TypeSupport type_key_struct(new key_structPubSubType()); + type_key_struct->register_type_object_representation(); - TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); - type_bitmask_struct->register_type_object_representation(); + TypeSupport type_map_struct(new map_structPubSubType()); + type_map_struct->register_type_object_representation(); - TypeSupport type_alias_struct(new alias_structPubSubType()); - type_alias_struct->register_type_object_representation(); + TypeSupport type_numeric_array(new numeric_arrayPubSubType()); + type_numeric_array->register_type_object_representation(); - TypeSupport type_key_struct(new key_structPubSubType()); - type_key_struct->register_type_object_representation(); + TypeSupport type_union_struct(new union_structPubSubType()); + type_union_struct->register_type_object_representation(); } } /* namespace test */ From 0d9ce7fa8d1ddcd7e547e7232ff088842dbcc735 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 09:50:15 +0200 Subject: [PATCH 30/52] Support Annotation @extensibility Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.ipp | 39 ++++++++++++++++++- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index 893d211ee1e..9b36eb524c2 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -839,8 +839,43 @@ ReturnCode_t struct_to_str( return RETCODE_BAD_PARAMETER; } + ReturnCode_t ret = RETCODE_OK; + + // Annotation with the extensibility kind + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + switch (type_descriptor->extensibility_kind()) + { + case ExtensibilityKind::FINAL: + { + struct_str = "@extensibility(FINAL)\n"; + break; + } + case ExtensibilityKind::MUTABLE: + { + struct_str = "@extensibility(MUTABLE)\n"; + break; + } + case ExtensibilityKind::APPENDABLE: + { + // Appendable is the default extensibility kind + break; + } + default: + { + EPROSIMA_LOG_ERROR(DYN_TYPES, "Extensibility kind not supported."); + return RETCODE_BAD_PARAMETER; + } + } + // Add types name - struct_str = "struct " + node.info.type_kind_name + TYPE_OPENING; + struct_str += "struct " + node.info.type_kind_name + TYPE_OPENING; // Add struct attributes for (auto const& child : node.branches()) @@ -854,7 +889,7 @@ ReturnCode_t struct_to_str( // Close definition struct_str += TYPE_CLOSURE; - return RETCODE_OK; + return ret; } ReturnCode_t union_to_str( From 3077276a644b4a993e3fe7cf5fe738772b856829 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 09:50:31 +0200 Subject: [PATCH 31/52] Tests - Annotation @extensibility Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 8 + .../types/idls/extensibility_struct.idl | 23 + .../extensibility_struct.hpp | 651 ++++++++++++++ .../extensibility_structCdrAux.hpp | 67 ++ .../extensibility_structCdrAux.ipp | 362 ++++++++ .../extensibility_structPubSubTypes.cxx | 808 ++++++++++++++++++ .../extensibility_structPubSubTypes.h | 461 ++++++++++ .../extensibility_structTypeObjectSupport.cxx | 345 ++++++++ .../extensibility_structTypeObjectSupport.hpp | 92 ++ 10 files changed, 2821 insertions(+) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index 1ffdcf884a4..6d9be435e3f 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -48,6 +48,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/enum_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/enum_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/extensibility_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/extensibility_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/float_bounded_sequence.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/float_bounded_sequence.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index af93baadc71..fa63b404243 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -47,6 +47,9 @@ #include "type_objects/enum_struct/enum_struct.hpp" #include "type_objects/enum_struct/enum_structPubSubTypes.h" +#include "type_objects/extensibility_struct/extensibility_struct.hpp" +#include "type_objects/extensibility_struct/extensibility_structPubSubTypes.h" + #include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" #include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" @@ -78,6 +81,7 @@ const std::string BITSET_STRUCT{"bitset_struct"}; const std::string CHAR_SEQUENCE{"char_sequence"}; const std::string COMPLEX_NESTED_ARRAYS{"complex_nested_arrays"}; const std::string ENUM_STRUCT{"enum_struct"}; +const std::string EXTENSIBILITY_STRUCT{"extensibility_struct"}; const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; const std::string HELLO_WORLD{"hello_world"}; const std::string KEY_STRUCT{"key_struct"}; @@ -97,6 +101,7 @@ const std::vector supported_types = { SupportedTypes::CHAR_SEQUENCE, SupportedTypes::COMPLEX_NESTED_ARRAYS, SupportedTypes::ENUM_STRUCT, + SupportedTypes::EXTENSIBILITY_STRUCT, SupportedTypes::FLOAT_BOUNDED_SEQUENCE, SupportedTypes::HELLO_WORLD, SupportedTypes::KEY_STRUCT, @@ -136,6 +141,9 @@ void register_dynamic_types() TypeSupport type_enum_struct(new enum_structPubSubType()); type_enum_struct->register_type_object_representation(); + TypeSupport type_extensibility_struct(new extensibility_structPubSubType()); + type_extensibility_struct->register_type_object_representation(); + TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); type_float_bounded_sequence->register_type_object_representation(); diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl new file mode 100644 index 00000000000..c587eba0fd1 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl @@ -0,0 +1,23 @@ +@extensibility(FINAL) +struct FinalStruct +{ + octet color; +}; + +@extensibility(MUTABLE) +struct MutableStruct +{ + octet color; +}; + +struct AppendableStruct +{ + octet color; +}; + +struct extensibility_struct +{ + FinalStruct red; + MutableStruct blue; + AppendableStruct green; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp new file mode 100644 index 00000000000..886b11d2008 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp @@ -0,0 +1,651 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(EXTENSIBILITY_STRUCT_SOURCE) +#define EXTENSIBILITY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define EXTENSIBILITY_STRUCT_DllAPI __declspec( dllimport ) +#endif // EXTENSIBILITY_STRUCT_SOURCE +#else +#define EXTENSIBILITY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define EXTENSIBILITY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure FinalStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class FinalStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FinalStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FinalStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FinalStruct that will be copied. + */ + eProsima_user_DllExport FinalStruct( + const FinalStruct& x) + { + m_color = x.m_color; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FinalStruct that will be copied. + */ + eProsima_user_DllExport FinalStruct( + FinalStruct&& x) noexcept + { + m_color = x.m_color; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FinalStruct that will be copied. + */ + eProsima_user_DllExport FinalStruct& operator =( + const FinalStruct& x) + { + + m_color = x.m_color; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FinalStruct that will be copied. + */ + eProsima_user_DllExport FinalStruct& operator =( + FinalStruct&& x) noexcept + { + + m_color = x.m_color; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FinalStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FinalStruct& x) const + { + return (m_color == x.m_color); + } + + /*! + * @brief Comparison operator. + * @param x FinalStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FinalStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member color + * @param _color New value for member color + */ + eProsima_user_DllExport void color( + uint8_t _color) + { + m_color = _color; + } + + /*! + * @brief This function returns the value of member color + * @return Value of member color + */ + eProsima_user_DllExport uint8_t color() const + { + return m_color; + } + + /*! + * @brief This function returns a reference to member color + * @return Reference to member color + */ + eProsima_user_DllExport uint8_t& color() + { + return m_color; + } + + + +private: + + uint8_t m_color{0}; + +}; +/*! + * @brief This class represents the structure MutableStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class MutableStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport MutableStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~MutableStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object MutableStruct that will be copied. + */ + eProsima_user_DllExport MutableStruct( + const MutableStruct& x) + { + m_color = x.m_color; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object MutableStruct that will be copied. + */ + eProsima_user_DllExport MutableStruct( + MutableStruct&& x) noexcept + { + m_color = x.m_color; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object MutableStruct that will be copied. + */ + eProsima_user_DllExport MutableStruct& operator =( + const MutableStruct& x) + { + + m_color = x.m_color; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object MutableStruct that will be copied. + */ + eProsima_user_DllExport MutableStruct& operator =( + MutableStruct&& x) noexcept + { + + m_color = x.m_color; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x MutableStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const MutableStruct& x) const + { + return (m_color == x.m_color); + } + + /*! + * @brief Comparison operator. + * @param x MutableStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const MutableStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member color + * @param _color New value for member color + */ + eProsima_user_DllExport void color( + uint8_t _color) + { + m_color = _color; + } + + /*! + * @brief This function returns the value of member color + * @return Value of member color + */ + eProsima_user_DllExport uint8_t color() const + { + return m_color; + } + + /*! + * @brief This function returns a reference to member color + * @return Reference to member color + */ + eProsima_user_DllExport uint8_t& color() + { + return m_color; + } + + + +private: + + uint8_t m_color{0}; + +}; +/*! + * @brief This class represents the structure AppendableStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class AppendableStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport AppendableStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~AppendableStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object AppendableStruct that will be copied. + */ + eProsima_user_DllExport AppendableStruct( + const AppendableStruct& x) + { + m_color = x.m_color; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object AppendableStruct that will be copied. + */ + eProsima_user_DllExport AppendableStruct( + AppendableStruct&& x) noexcept + { + m_color = x.m_color; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object AppendableStruct that will be copied. + */ + eProsima_user_DllExport AppendableStruct& operator =( + const AppendableStruct& x) + { + + m_color = x.m_color; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object AppendableStruct that will be copied. + */ + eProsima_user_DllExport AppendableStruct& operator =( + AppendableStruct&& x) noexcept + { + + m_color = x.m_color; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x AppendableStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const AppendableStruct& x) const + { + return (m_color == x.m_color); + } + + /*! + * @brief Comparison operator. + * @param x AppendableStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const AppendableStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member color + * @param _color New value for member color + */ + eProsima_user_DllExport void color( + uint8_t _color) + { + m_color = _color; + } + + /*! + * @brief This function returns the value of member color + * @return Value of member color + */ + eProsima_user_DllExport uint8_t color() const + { + return m_color; + } + + /*! + * @brief This function returns a reference to member color + * @return Reference to member color + */ + eProsima_user_DllExport uint8_t& color() + { + return m_color; + } + + + +private: + + uint8_t m_color{0}; + +}; +/*! + * @brief This class represents the structure extensibility_struct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class extensibility_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport extensibility_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~extensibility_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object extensibility_struct that will be copied. + */ + eProsima_user_DllExport extensibility_struct( + const extensibility_struct& x) + { + m_red = x.m_red; + + m_blue = x.m_blue; + + m_green = x.m_green; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object extensibility_struct that will be copied. + */ + eProsima_user_DllExport extensibility_struct( + extensibility_struct&& x) noexcept + { + m_red = std::move(x.m_red); + m_blue = std::move(x.m_blue); + m_green = std::move(x.m_green); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object extensibility_struct that will be copied. + */ + eProsima_user_DllExport extensibility_struct& operator =( + const extensibility_struct& x) + { + + m_red = x.m_red; + + m_blue = x.m_blue; + + m_green = x.m_green; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object extensibility_struct that will be copied. + */ + eProsima_user_DllExport extensibility_struct& operator =( + extensibility_struct&& x) noexcept + { + + m_red = std::move(x.m_red); + m_blue = std::move(x.m_blue); + m_green = std::move(x.m_green); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x extensibility_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const extensibility_struct& x) const + { + return (m_red == x.m_red && + m_blue == x.m_blue && + m_green == x.m_green); + } + + /*! + * @brief Comparison operator. + * @param x extensibility_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const extensibility_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member red + * @param _red New value to be copied in member red + */ + eProsima_user_DllExport void red( + const FinalStruct& _red) + { + m_red = _red; + } + + /*! + * @brief This function moves the value in member red + * @param _red New value to be moved in member red + */ + eProsima_user_DllExport void red( + FinalStruct&& _red) + { + m_red = std::move(_red); + } + + /*! + * @brief This function returns a constant reference to member red + * @return Constant reference to member red + */ + eProsima_user_DllExport const FinalStruct& red() const + { + return m_red; + } + + /*! + * @brief This function returns a reference to member red + * @return Reference to member red + */ + eProsima_user_DllExport FinalStruct& red() + { + return m_red; + } + + + /*! + * @brief This function copies the value in member blue + * @param _blue New value to be copied in member blue + */ + eProsima_user_DllExport void blue( + const MutableStruct& _blue) + { + m_blue = _blue; + } + + /*! + * @brief This function moves the value in member blue + * @param _blue New value to be moved in member blue + */ + eProsima_user_DllExport void blue( + MutableStruct&& _blue) + { + m_blue = std::move(_blue); + } + + /*! + * @brief This function returns a constant reference to member blue + * @return Constant reference to member blue + */ + eProsima_user_DllExport const MutableStruct& blue() const + { + return m_blue; + } + + /*! + * @brief This function returns a reference to member blue + * @return Reference to member blue + */ + eProsima_user_DllExport MutableStruct& blue() + { + return m_blue; + } + + + /*! + * @brief This function copies the value in member green + * @param _green New value to be copied in member green + */ + eProsima_user_DllExport void green( + const AppendableStruct& _green) + { + m_green = _green; + } + + /*! + * @brief This function moves the value in member green + * @param _green New value to be moved in member green + */ + eProsima_user_DllExport void green( + AppendableStruct&& _green) + { + m_green = std::move(_green); + } + + /*! + * @brief This function returns a constant reference to member green + * @return Constant reference to member green + */ + eProsima_user_DllExport const AppendableStruct& green() const + { + return m_green; + } + + /*! + * @brief This function returns a reference to member green + * @return Reference to member green + */ + eProsima_user_DllExport AppendableStruct& green() + { + return m_green; + } + + + +private: + + FinalStruct m_red; + MutableStruct m_blue; + AppendableStruct m_green; + +}; + +#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp new file mode 100644 index 00000000000..b70ed7741ea --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp @@ -0,0 +1,67 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ + +#include "extensibility_struct.hpp" + +constexpr uint32_t MutableStruct_max_cdr_typesize {12UL}; +constexpr uint32_t MutableStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t FinalStruct_max_cdr_typesize {1UL}; +constexpr uint32_t FinalStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t AppendableStruct_max_cdr_typesize {5UL}; +constexpr uint32_t AppendableStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t extensibility_struct_max_cdr_typesize {25UL}; +constexpr uint32_t extensibility_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FinalStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const MutableStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const AppendableStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const extensibility_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp new file mode 100644 index 00000000000..48cf7f1a445 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp @@ -0,0 +1,362 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ + +#include "extensibility_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FinalStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.color(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FinalStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.color() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FinalStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.color(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FinalStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const MutableStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0x00000000), + data.color(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const MutableStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR); + + scdr + << eprosima::fastcdr::MemberId(0x00000000) << data.color() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + MutableStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0x00000000: + dcdr >> data.color(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const MutableStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const AppendableStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.color(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const AppendableStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.color() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + AppendableStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.color(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const AppendableStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const extensibility_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.red(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.blue(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.green(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const extensibility_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.red() + << eprosima::fastcdr::MemberId(1) << data.blue() + << eprosima::fastcdr::MemberId(2) << data.green() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + extensibility_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.red(); + break; + + case 1: + dcdr >> data.blue(); + break; + + case 2: + dcdr >> data.green(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const extensibility_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx new file mode 100644 index 00000000000..43ef557bf1b --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx @@ -0,0 +1,808 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "extensibility_structPubSubTypes.h" + +#include +#include + +#include "extensibility_structCdrAux.hpp" +#include "extensibility_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +FinalStructPubSubType::FinalStructPubSubType() +{ + setName("FinalStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FinalStruct::getMaxCdrSerializedSize()); +#else + FinalStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FinalStruct_max_key_cdr_typesize > 16 ? FinalStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FinalStructPubSubType::~FinalStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FinalStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FinalStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FinalStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FinalStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FinalStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FinalStructPubSubType::createData() +{ + return reinterpret_cast(new FinalStruct()); +} + +void FinalStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FinalStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FinalStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FinalStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FinalStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FinalStructPubSubType::register_type_object_representation() +{ + register_FinalStruct_type_identifier(type_identifiers_); +} + +MutableStructPubSubType::MutableStructPubSubType() +{ + setName("MutableStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(MutableStruct::getMaxCdrSerializedSize()); +#else + MutableStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = MutableStruct_max_key_cdr_typesize > 16 ? MutableStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +MutableStructPubSubType::~MutableStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool MutableStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + MutableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool MutableStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + MutableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function MutableStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* MutableStructPubSubType::createData() +{ + return reinterpret_cast(new MutableStruct()); +} + +void MutableStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool MutableStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + MutableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + MutableStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || MutableStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void MutableStructPubSubType::register_type_object_representation() +{ + register_MutableStruct_type_identifier(type_identifiers_); +} + +AppendableStructPubSubType::AppendableStructPubSubType() +{ + setName("AppendableStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(AppendableStruct::getMaxCdrSerializedSize()); +#else + AppendableStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = AppendableStruct_max_key_cdr_typesize > 16 ? AppendableStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +AppendableStructPubSubType::~AppendableStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool AppendableStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + AppendableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool AppendableStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + AppendableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function AppendableStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* AppendableStructPubSubType::createData() +{ + return reinterpret_cast(new AppendableStruct()); +} + +void AppendableStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool AppendableStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + AppendableStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + AppendableStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || AppendableStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void AppendableStructPubSubType::register_type_object_representation() +{ + register_AppendableStruct_type_identifier(type_identifiers_); +} + +extensibility_structPubSubType::extensibility_structPubSubType() +{ + setName("extensibility_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(extensibility_struct::getMaxCdrSerializedSize()); +#else + extensibility_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = extensibility_struct_max_key_cdr_typesize > 16 ? extensibility_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +extensibility_structPubSubType::~extensibility_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool extensibility_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + extensibility_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool extensibility_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + extensibility_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function extensibility_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* extensibility_structPubSubType::createData() +{ + return reinterpret_cast(new extensibility_struct()); +} + +void extensibility_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool extensibility_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + extensibility_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + extensibility_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || extensibility_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void extensibility_structPubSubType::register_type_object_representation() +{ + register_extensibility_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "extensibility_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h new file mode 100644 index 00000000000..9debe862be5 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h @@ -0,0 +1,461 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "extensibility_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated extensibility_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +#ifndef SWIG +namespace detail { + +template +struct FinalStruct_rob +{ + friend constexpr typename Tag::type get( + Tag) + { + return M; + } + +}; + +struct FinalStruct_f +{ + typedef uint8_t FinalStruct::* type; + friend constexpr type get( + FinalStruct_f); +}; + +template struct FinalStruct_rob; + +template +inline size_t constexpr FinalStruct_offset_of() +{ + return ((::size_t) &reinterpret_cast((((T*)0)->*get(Tag())))); +} + +} // namespace detail +#endif // ifndef SWIG + + +/*! + * @brief This class represents the TopicDataType of the type FinalStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class FinalStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FinalStruct type; + + eProsima_user_DllExport FinalStructPubSubType(); + + eProsima_user_DllExport ~FinalStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return is_plain_xcdrv1_impl(); + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + if(data_representation == eprosima::fastdds::dds::DataRepresentationId_t::XCDR2_DATA_REPRESENTATION) + { + return is_plain_xcdrv2_impl(); + } + else + { + return is_plain_xcdrv1_impl(); + } + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + new (memory) FinalStruct(); + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +private: + + static constexpr bool is_plain_xcdrv1_impl() + { + return 1ULL == + (detail::FinalStruct_offset_of() + + sizeof(uint8_t)); + } + + static constexpr bool is_plain_xcdrv2_impl() + { + return 1ULL == + (detail::FinalStruct_offset_of() + + sizeof(uint8_t)); + } + +}; + +/*! + * @brief This class represents the TopicDataType of the type MutableStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class MutableStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef MutableStruct type; + + eProsima_user_DllExport MutableStructPubSubType(); + + eProsima_user_DllExport ~MutableStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type AppendableStruct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef AppendableStruct type; + + eProsima_user_DllExport AppendableStructPubSubType(); + + eProsima_user_DllExport ~AppendableStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type extensibility_struct defined by the user in the IDL file. + * @ingroup extensibility_struct + */ +class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef extensibility_struct type; + + eProsima_user_DllExport extensibility_structPubSubType(); + + eProsima_user_DllExport ~extensibility_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..860f5c8368c --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx @@ -0,0 +1,345 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "extensibility_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "extensibility_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FinalStruct_type_identifier( + TypeIdentifierPair& type_ids_FinalStruct) +{ + + ReturnCode_t return_code_FinalStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FinalStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FinalStruct", type_ids_FinalStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FinalStruct) + { + StructTypeFlag struct_flags_FinalStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::FINAL, + false, false); + QualifiedTypeName type_name_FinalStruct = "FinalStruct"; + eprosima::fastcdr::optional type_ann_builtin_FinalStruct; + eprosima::fastcdr::optional ann_custom_FinalStruct; + AppliedAnnotationSeq tmp_ann_custom_FinalStruct; + eprosima::fastcdr::optional verbatim_FinalStruct; + if (!tmp_ann_custom_FinalStruct.empty()) + { + ann_custom_FinalStruct = tmp_ann_custom_FinalStruct; + } + + CompleteTypeDetail detail_FinalStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FinalStruct, ann_custom_FinalStruct, type_name_FinalStruct.to_string()); + CompleteStructHeader header_FinalStruct; + header_FinalStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FinalStruct); + CompleteStructMemberSeq member_seq_FinalStruct; + { + TypeIdentifierPair type_ids_color; + ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; + return_code_color = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_byte", type_ids_color); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_color = 0x00000000; + bool common_color_ec {false}; + CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; + if (!common_color_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + return; + } + MemberName name_color = "color"; + eprosima::fastcdr::optional member_ann_builtin_color; + ann_custom_FinalStruct.reset(); + CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_FinalStruct); + CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); + TypeObjectUtils::add_complete_struct_member(member_seq_FinalStruct, member_color); + } + CompleteStructType struct_type_FinalStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FinalStruct, header_FinalStruct, member_seq_FinalStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FinalStruct, type_name_FinalStruct.to_string(), type_ids_FinalStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FinalStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_MutableStruct_type_identifier( + TypeIdentifierPair& type_ids_MutableStruct) +{ + + ReturnCode_t return_code_MutableStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MutableStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MutableStruct", type_ids_MutableStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MutableStruct) + { + StructTypeFlag struct_flags_MutableStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::MUTABLE, + false, false); + QualifiedTypeName type_name_MutableStruct = "MutableStruct"; + eprosima::fastcdr::optional type_ann_builtin_MutableStruct; + eprosima::fastcdr::optional ann_custom_MutableStruct; + AppliedAnnotationSeq tmp_ann_custom_MutableStruct; + eprosima::fastcdr::optional verbatim_MutableStruct; + if (!tmp_ann_custom_MutableStruct.empty()) + { + ann_custom_MutableStruct = tmp_ann_custom_MutableStruct; + } + + CompleteTypeDetail detail_MutableStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MutableStruct, ann_custom_MutableStruct, type_name_MutableStruct.to_string()); + CompleteStructHeader header_MutableStruct; + header_MutableStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_MutableStruct); + CompleteStructMemberSeq member_seq_MutableStruct; + { + TypeIdentifierPair type_ids_color; + ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; + return_code_color = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_byte", type_ids_color); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_color = 0x00000000; + bool common_color_ec {false}; + CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; + if (!common_color_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + return; + } + MemberName name_color = "color"; + eprosima::fastcdr::optional member_ann_builtin_color; + ann_custom_MutableStruct.reset(); + CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_MutableStruct); + CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); + TypeObjectUtils::add_complete_struct_member(member_seq_MutableStruct, member_color); + } + CompleteStructType struct_type_MutableStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_MutableStruct, header_MutableStruct, member_seq_MutableStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_MutableStruct, type_name_MutableStruct.to_string(), type_ids_MutableStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MutableStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_AppendableStruct_type_identifier( + TypeIdentifierPair& type_ids_AppendableStruct) +{ + + ReturnCode_t return_code_AppendableStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_AppendableStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AppendableStruct", type_ids_AppendableStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_AppendableStruct) + { + StructTypeFlag struct_flags_AppendableStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_AppendableStruct = "AppendableStruct"; + eprosima::fastcdr::optional type_ann_builtin_AppendableStruct; + eprosima::fastcdr::optional ann_custom_AppendableStruct; + CompleteTypeDetail detail_AppendableStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_AppendableStruct, ann_custom_AppendableStruct, type_name_AppendableStruct.to_string()); + CompleteStructHeader header_AppendableStruct; + header_AppendableStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AppendableStruct); + CompleteStructMemberSeq member_seq_AppendableStruct; + { + TypeIdentifierPair type_ids_color; + ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; + return_code_color = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_byte", type_ids_color); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_color = 0x00000000; + bool common_color_ec {false}; + CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; + if (!common_color_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + return; + } + MemberName name_color = "color"; + eprosima::fastcdr::optional member_ann_builtin_color; + ann_custom_AppendableStruct.reset(); + CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_AppendableStruct); + CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); + TypeObjectUtils::add_complete_struct_member(member_seq_AppendableStruct, member_color); + } + CompleteStructType struct_type_AppendableStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AppendableStruct, header_AppendableStruct, member_seq_AppendableStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_AppendableStruct, type_name_AppendableStruct.to_string(), type_ids_AppendableStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "AppendableStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_extensibility_struct_type_identifier( + TypeIdentifierPair& type_ids_extensibility_struct) +{ + + ReturnCode_t return_code_extensibility_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_extensibility_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "extensibility_struct", type_ids_extensibility_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_extensibility_struct) + { + StructTypeFlag struct_flags_extensibility_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_extensibility_struct = "extensibility_struct"; + eprosima::fastcdr::optional type_ann_builtin_extensibility_struct; + eprosima::fastcdr::optional ann_custom_extensibility_struct; + CompleteTypeDetail detail_extensibility_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_extensibility_struct, ann_custom_extensibility_struct, type_name_extensibility_struct.to_string()); + CompleteStructHeader header_extensibility_struct; + header_extensibility_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_extensibility_struct); + CompleteStructMemberSeq member_seq_extensibility_struct; + { + TypeIdentifierPair type_ids_red; + ReturnCode_t return_code_red {eprosima::fastdds::dds::RETCODE_OK}; + return_code_red = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FinalStruct", type_ids_red); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_red) + { + ::register_FinalStruct_type_identifier(type_ids_red); + } + StructMemberFlag member_flags_red = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_red = 0x00000000; + bool common_red_ec {false}; + CommonStructMember common_red {TypeObjectUtils::build_common_struct_member(member_id_red, member_flags_red, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_red, common_red_ec))}; + if (!common_red_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure red member TypeIdentifier inconsistent."); + return; + } + MemberName name_red = "red"; + eprosima::fastcdr::optional member_ann_builtin_red; + ann_custom_extensibility_struct.reset(); + CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_extensibility_struct); + CompleteStructMember member_red = TypeObjectUtils::build_complete_struct_member(common_red, detail_red); + TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_red); + } + { + TypeIdentifierPair type_ids_blue; + ReturnCode_t return_code_blue {eprosima::fastdds::dds::RETCODE_OK}; + return_code_blue = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MutableStruct", type_ids_blue); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_blue) + { + ::register_MutableStruct_type_identifier(type_ids_blue); + } + StructMemberFlag member_flags_blue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_blue = 0x00000001; + bool common_blue_ec {false}; + CommonStructMember common_blue {TypeObjectUtils::build_common_struct_member(member_id_blue, member_flags_blue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_blue, common_blue_ec))}; + if (!common_blue_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure blue member TypeIdentifier inconsistent."); + return; + } + MemberName name_blue = "blue"; + eprosima::fastcdr::optional member_ann_builtin_blue; + ann_custom_extensibility_struct.reset(); + CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_extensibility_struct); + CompleteStructMember member_blue = TypeObjectUtils::build_complete_struct_member(common_blue, detail_blue); + TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_blue); + } + { + TypeIdentifierPair type_ids_green; + ReturnCode_t return_code_green {eprosima::fastdds::dds::RETCODE_OK}; + return_code_green = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "AppendableStruct", type_ids_green); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_green) + { + ::register_AppendableStruct_type_identifier(type_ids_green); + } + StructMemberFlag member_flags_green = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_green = 0x00000002; + bool common_green_ec {false}; + CommonStructMember common_green {TypeObjectUtils::build_common_struct_member(member_id_green, member_flags_green, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_green, common_green_ec))}; + if (!common_green_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure green member TypeIdentifier inconsistent."); + return; + } + MemberName name_green = "green"; + eprosima::fastcdr::optional member_ann_builtin_green; + ann_custom_extensibility_struct.reset(); + CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_extensibility_struct); + CompleteStructMember member_green = TypeObjectUtils::build_complete_struct_member(common_green, detail_green); + TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_green); + } + CompleteStructType struct_type_extensibility_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_extensibility_struct, header_extensibility_struct, member_seq_extensibility_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_extensibility_struct, type_name_extensibility_struct.to_string(), type_ids_extensibility_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "extensibility_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..a6636cc6246 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp @@ -0,0 +1,92 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file extensibility_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register FinalStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FinalStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register MutableStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MutableStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register AppendableStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_AppendableStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register extensibility_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_extensibility_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From 2e54986d0e40fdcc180782dff275e795cffc23f1 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 10:51:20 +0200 Subject: [PATCH 32/52] Tests - Nested Struct Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 8 + .../types/idls/nested_struct.idl | 33 + .../nested_struct/nested_struct.hpp | 1031 ++++++++++++++ .../nested_struct/nested_structCdrAux.hpp | 81 ++ .../nested_struct/nested_structCdrAux.ipp | 530 ++++++++ .../nested_structPubSubTypes.cxx | 1194 +++++++++++++++++ .../nested_struct/nested_structPubSubTypes.h | 588 ++++++++ .../nested_structTypeObjectSupport.cxx | 497 +++++++ .../nested_structTypeObjectSupport.hpp | 116 ++ 10 files changed, 4082 insertions(+) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index 6d9be435e3f..7471d1e113e 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -68,6 +68,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/nested_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/nested_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index fa63b404243..e6578e76ad6 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -62,6 +62,9 @@ #include "type_objects/map_struct/map_struct.hpp" #include "type_objects/map_struct/map_structPubSubTypes.h" +#include "type_objects/nested_struct/nested_struct.hpp" +#include "type_objects/nested_struct/nested_structPubSubTypes.h" + #include "type_objects/numeric_array/numeric_array.hpp" #include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" @@ -86,6 +89,7 @@ const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; const std::string HELLO_WORLD{"hello_world"}; const std::string KEY_STRUCT{"key_struct"}; const std::string MAP_STRUCT{"map_struct"}; +const std::string NESTED_STRUCT{"nested_struct"}; const std::string NUMERIC_ARRAY{"numeric_array"}; const std::string UNION_STRUCT{"union_struct"}; @@ -106,6 +110,7 @@ const std::vector supported_types = { SupportedTypes::HELLO_WORLD, SupportedTypes::KEY_STRUCT, SupportedTypes::MAP_STRUCT, + SupportedTypes::NESTED_STRUCT, SupportedTypes::NUMERIC_ARRAY, SupportedTypes::UNION_STRUCT }; @@ -156,6 +161,9 @@ void register_dynamic_types() TypeSupport type_map_struct(new map_structPubSubType()); type_map_struct->register_type_object_representation(); + TypeSupport type_nested_struct(new nested_structPubSubType()); + type_nested_struct->register_type_object_representation(); + TypeSupport type_numeric_array(new numeric_arrayPubSubType()); type_numeric_array->register_type_object_representation(); diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl new file mode 100644 index 00000000000..0d1f5f71f69 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl @@ -0,0 +1,33 @@ +struct FirstStruct +{ + long value; +}; + +struct SecondStruct +{ + FirstStruct first; +}; + +struct ThirdStruct +{ + SecondStruct second; +}; + +struct FourthStruct +{ + ThirdStruct third; +}; + +struct FifthStruct +{ + FourthStruct fourth; +}; + +struct nested_struct +{ + FirstStruct first; + SecondStruct second; + ThirdStruct third; + FourthStruct fourth; + FifthStruct fifth; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp new file mode 100644 index 00000000000..f4f172391c2 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp @@ -0,0 +1,1031 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(NESTED_STRUCT_SOURCE) +#define NESTED_STRUCT_DllAPI __declspec( dllexport ) +#else +#define NESTED_STRUCT_DllAPI __declspec( dllimport ) +#endif // NESTED_STRUCT_SOURCE +#else +#define NESTED_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define NESTED_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure FirstStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FirstStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FirstStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FirstStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FirstStruct that will be copied. + */ + eProsima_user_DllExport FirstStruct( + const FirstStruct& x) + { + m_value = x.m_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FirstStruct that will be copied. + */ + eProsima_user_DllExport FirstStruct( + FirstStruct&& x) noexcept + { + m_value = x.m_value; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FirstStruct that will be copied. + */ + eProsima_user_DllExport FirstStruct& operator =( + const FirstStruct& x) + { + + m_value = x.m_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FirstStruct that will be copied. + */ + eProsima_user_DllExport FirstStruct& operator =( + FirstStruct&& x) noexcept + { + + m_value = x.m_value; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FirstStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FirstStruct& x) const + { + return (m_value == x.m_value); + } + + /*! + * @brief Comparison operator. + * @param x FirstStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FirstStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member value + * @param _value New value for member value + */ + eProsima_user_DllExport void value( + int32_t _value) + { + m_value = _value; + } + + /*! + * @brief This function returns the value of member value + * @return Value of member value + */ + eProsima_user_DllExport int32_t value() const + { + return m_value; + } + + /*! + * @brief This function returns a reference to member value + * @return Reference to member value + */ + eProsima_user_DllExport int32_t& value() + { + return m_value; + } + + + +private: + + int32_t m_value{0}; + +}; +/*! + * @brief This class represents the structure SecondStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class SecondStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport SecondStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~SecondStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object SecondStruct that will be copied. + */ + eProsima_user_DllExport SecondStruct( + const SecondStruct& x) + { + m_first = x.m_first; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object SecondStruct that will be copied. + */ + eProsima_user_DllExport SecondStruct( + SecondStruct&& x) noexcept + { + m_first = std::move(x.m_first); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object SecondStruct that will be copied. + */ + eProsima_user_DllExport SecondStruct& operator =( + const SecondStruct& x) + { + + m_first = x.m_first; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object SecondStruct that will be copied. + */ + eProsima_user_DllExport SecondStruct& operator =( + SecondStruct&& x) noexcept + { + + m_first = std::move(x.m_first); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x SecondStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const SecondStruct& x) const + { + return (m_first == x.m_first); + } + + /*! + * @brief Comparison operator. + * @param x SecondStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const SecondStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member first + * @param _first New value to be copied in member first + */ + eProsima_user_DllExport void first( + const FirstStruct& _first) + { + m_first = _first; + } + + /*! + * @brief This function moves the value in member first + * @param _first New value to be moved in member first + */ + eProsima_user_DllExport void first( + FirstStruct&& _first) + { + m_first = std::move(_first); + } + + /*! + * @brief This function returns a constant reference to member first + * @return Constant reference to member first + */ + eProsima_user_DllExport const FirstStruct& first() const + { + return m_first; + } + + /*! + * @brief This function returns a reference to member first + * @return Reference to member first + */ + eProsima_user_DllExport FirstStruct& first() + { + return m_first; + } + + + +private: + + FirstStruct m_first; + +}; +/*! + * @brief This class represents the structure ThirdStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class ThirdStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ThirdStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ThirdStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ThirdStruct that will be copied. + */ + eProsima_user_DllExport ThirdStruct( + const ThirdStruct& x) + { + m_second = x.m_second; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ThirdStruct that will be copied. + */ + eProsima_user_DllExport ThirdStruct( + ThirdStruct&& x) noexcept + { + m_second = std::move(x.m_second); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ThirdStruct that will be copied. + */ + eProsima_user_DllExport ThirdStruct& operator =( + const ThirdStruct& x) + { + + m_second = x.m_second; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ThirdStruct that will be copied. + */ + eProsima_user_DllExport ThirdStruct& operator =( + ThirdStruct&& x) noexcept + { + + m_second = std::move(x.m_second); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ThirdStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ThirdStruct& x) const + { + return (m_second == x.m_second); + } + + /*! + * @brief Comparison operator. + * @param x ThirdStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ThirdStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member second + * @param _second New value to be copied in member second + */ + eProsima_user_DllExport void second( + const SecondStruct& _second) + { + m_second = _second; + } + + /*! + * @brief This function moves the value in member second + * @param _second New value to be moved in member second + */ + eProsima_user_DllExport void second( + SecondStruct&& _second) + { + m_second = std::move(_second); + } + + /*! + * @brief This function returns a constant reference to member second + * @return Constant reference to member second + */ + eProsima_user_DllExport const SecondStruct& second() const + { + return m_second; + } + + /*! + * @brief This function returns a reference to member second + * @return Reference to member second + */ + eProsima_user_DllExport SecondStruct& second() + { + return m_second; + } + + + +private: + + SecondStruct m_second; + +}; +/*! + * @brief This class represents the structure FourthStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FourthStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FourthStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FourthStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FourthStruct that will be copied. + */ + eProsima_user_DllExport FourthStruct( + const FourthStruct& x) + { + m_third = x.m_third; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FourthStruct that will be copied. + */ + eProsima_user_DllExport FourthStruct( + FourthStruct&& x) noexcept + { + m_third = std::move(x.m_third); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FourthStruct that will be copied. + */ + eProsima_user_DllExport FourthStruct& operator =( + const FourthStruct& x) + { + + m_third = x.m_third; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FourthStruct that will be copied. + */ + eProsima_user_DllExport FourthStruct& operator =( + FourthStruct&& x) noexcept + { + + m_third = std::move(x.m_third); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FourthStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FourthStruct& x) const + { + return (m_third == x.m_third); + } + + /*! + * @brief Comparison operator. + * @param x FourthStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FourthStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member third + * @param _third New value to be copied in member third + */ + eProsima_user_DllExport void third( + const ThirdStruct& _third) + { + m_third = _third; + } + + /*! + * @brief This function moves the value in member third + * @param _third New value to be moved in member third + */ + eProsima_user_DllExport void third( + ThirdStruct&& _third) + { + m_third = std::move(_third); + } + + /*! + * @brief This function returns a constant reference to member third + * @return Constant reference to member third + */ + eProsima_user_DllExport const ThirdStruct& third() const + { + return m_third; + } + + /*! + * @brief This function returns a reference to member third + * @return Reference to member third + */ + eProsima_user_DllExport ThirdStruct& third() + { + return m_third; + } + + + +private: + + ThirdStruct m_third; + +}; +/*! + * @brief This class represents the structure FifthStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FifthStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FifthStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FifthStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FifthStruct that will be copied. + */ + eProsima_user_DllExport FifthStruct( + const FifthStruct& x) + { + m_fourth = x.m_fourth; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FifthStruct that will be copied. + */ + eProsima_user_DllExport FifthStruct( + FifthStruct&& x) noexcept + { + m_fourth = std::move(x.m_fourth); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FifthStruct that will be copied. + */ + eProsima_user_DllExport FifthStruct& operator =( + const FifthStruct& x) + { + + m_fourth = x.m_fourth; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FifthStruct that will be copied. + */ + eProsima_user_DllExport FifthStruct& operator =( + FifthStruct&& x) noexcept + { + + m_fourth = std::move(x.m_fourth); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FifthStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FifthStruct& x) const + { + return (m_fourth == x.m_fourth); + } + + /*! + * @brief Comparison operator. + * @param x FifthStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FifthStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member fourth + * @param _fourth New value to be copied in member fourth + */ + eProsima_user_DllExport void fourth( + const FourthStruct& _fourth) + { + m_fourth = _fourth; + } + + /*! + * @brief This function moves the value in member fourth + * @param _fourth New value to be moved in member fourth + */ + eProsima_user_DllExport void fourth( + FourthStruct&& _fourth) + { + m_fourth = std::move(_fourth); + } + + /*! + * @brief This function returns a constant reference to member fourth + * @return Constant reference to member fourth + */ + eProsima_user_DllExport const FourthStruct& fourth() const + { + return m_fourth; + } + + /*! + * @brief This function returns a reference to member fourth + * @return Reference to member fourth + */ + eProsima_user_DllExport FourthStruct& fourth() + { + return m_fourth; + } + + + +private: + + FourthStruct m_fourth; + +}; +/*! + * @brief This class represents the structure nested_struct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class nested_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport nested_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~nested_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object nested_struct that will be copied. + */ + eProsima_user_DllExport nested_struct( + const nested_struct& x) + { + m_first = x.m_first; + + m_second = x.m_second; + + m_third = x.m_third; + + m_fourth = x.m_fourth; + + m_fifth = x.m_fifth; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object nested_struct that will be copied. + */ + eProsima_user_DllExport nested_struct( + nested_struct&& x) noexcept + { + m_first = std::move(x.m_first); + m_second = std::move(x.m_second); + m_third = std::move(x.m_third); + m_fourth = std::move(x.m_fourth); + m_fifth = std::move(x.m_fifth); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object nested_struct that will be copied. + */ + eProsima_user_DllExport nested_struct& operator =( + const nested_struct& x) + { + + m_first = x.m_first; + + m_second = x.m_second; + + m_third = x.m_third; + + m_fourth = x.m_fourth; + + m_fifth = x.m_fifth; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object nested_struct that will be copied. + */ + eProsima_user_DllExport nested_struct& operator =( + nested_struct&& x) noexcept + { + + m_first = std::move(x.m_first); + m_second = std::move(x.m_second); + m_third = std::move(x.m_third); + m_fourth = std::move(x.m_fourth); + m_fifth = std::move(x.m_fifth); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x nested_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const nested_struct& x) const + { + return (m_first == x.m_first && + m_second == x.m_second && + m_third == x.m_third && + m_fourth == x.m_fourth && + m_fifth == x.m_fifth); + } + + /*! + * @brief Comparison operator. + * @param x nested_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const nested_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member first + * @param _first New value to be copied in member first + */ + eProsima_user_DllExport void first( + const FirstStruct& _first) + { + m_first = _first; + } + + /*! + * @brief This function moves the value in member first + * @param _first New value to be moved in member first + */ + eProsima_user_DllExport void first( + FirstStruct&& _first) + { + m_first = std::move(_first); + } + + /*! + * @brief This function returns a constant reference to member first + * @return Constant reference to member first + */ + eProsima_user_DllExport const FirstStruct& first() const + { + return m_first; + } + + /*! + * @brief This function returns a reference to member first + * @return Reference to member first + */ + eProsima_user_DllExport FirstStruct& first() + { + return m_first; + } + + + /*! + * @brief This function copies the value in member second + * @param _second New value to be copied in member second + */ + eProsima_user_DllExport void second( + const SecondStruct& _second) + { + m_second = _second; + } + + /*! + * @brief This function moves the value in member second + * @param _second New value to be moved in member second + */ + eProsima_user_DllExport void second( + SecondStruct&& _second) + { + m_second = std::move(_second); + } + + /*! + * @brief This function returns a constant reference to member second + * @return Constant reference to member second + */ + eProsima_user_DllExport const SecondStruct& second() const + { + return m_second; + } + + /*! + * @brief This function returns a reference to member second + * @return Reference to member second + */ + eProsima_user_DllExport SecondStruct& second() + { + return m_second; + } + + + /*! + * @brief This function copies the value in member third + * @param _third New value to be copied in member third + */ + eProsima_user_DllExport void third( + const ThirdStruct& _third) + { + m_third = _third; + } + + /*! + * @brief This function moves the value in member third + * @param _third New value to be moved in member third + */ + eProsima_user_DllExport void third( + ThirdStruct&& _third) + { + m_third = std::move(_third); + } + + /*! + * @brief This function returns a constant reference to member third + * @return Constant reference to member third + */ + eProsima_user_DllExport const ThirdStruct& third() const + { + return m_third; + } + + /*! + * @brief This function returns a reference to member third + * @return Reference to member third + */ + eProsima_user_DllExport ThirdStruct& third() + { + return m_third; + } + + + /*! + * @brief This function copies the value in member fourth + * @param _fourth New value to be copied in member fourth + */ + eProsima_user_DllExport void fourth( + const FourthStruct& _fourth) + { + m_fourth = _fourth; + } + + /*! + * @brief This function moves the value in member fourth + * @param _fourth New value to be moved in member fourth + */ + eProsima_user_DllExport void fourth( + FourthStruct&& _fourth) + { + m_fourth = std::move(_fourth); + } + + /*! + * @brief This function returns a constant reference to member fourth + * @return Constant reference to member fourth + */ + eProsima_user_DllExport const FourthStruct& fourth() const + { + return m_fourth; + } + + /*! + * @brief This function returns a reference to member fourth + * @return Reference to member fourth + */ + eProsima_user_DllExport FourthStruct& fourth() + { + return m_fourth; + } + + + /*! + * @brief This function copies the value in member fifth + * @param _fifth New value to be copied in member fifth + */ + eProsima_user_DllExport void fifth( + const FifthStruct& _fifth) + { + m_fifth = _fifth; + } + + /*! + * @brief This function moves the value in member fifth + * @param _fifth New value to be moved in member fifth + */ + eProsima_user_DllExport void fifth( + FifthStruct&& _fifth) + { + m_fifth = std::move(_fifth); + } + + /*! + * @brief This function returns a constant reference to member fifth + * @return Constant reference to member fifth + */ + eProsima_user_DllExport const FifthStruct& fifth() const + { + return m_fifth; + } + + /*! + * @brief This function returns a reference to member fifth + * @return Reference to member fifth + */ + eProsima_user_DllExport FifthStruct& fifth() + { + return m_fifth; + } + + + +private: + + FirstStruct m_first; + SecondStruct m_second; + ThirdStruct m_third; + FourthStruct m_fourth; + FifthStruct m_fifth; + +}; + +#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp new file mode 100644 index 00000000000..49b144ef728 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp @@ -0,0 +1,81 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ + +#include "nested_struct.hpp" + +constexpr uint32_t FirstStruct_max_cdr_typesize {8UL}; +constexpr uint32_t FirstStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t SecondStruct_max_cdr_typesize {12UL}; +constexpr uint32_t SecondStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t FifthStruct_max_cdr_typesize {24UL}; +constexpr uint32_t FifthStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t nested_struct_max_cdr_typesize {84UL}; +constexpr uint32_t nested_struct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t ThirdStruct_max_cdr_typesize {16UL}; +constexpr uint32_t ThirdStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t FourthStruct_max_cdr_typesize {20UL}; +constexpr uint32_t FourthStruct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FirstStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SecondStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ThirdStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FourthStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FifthStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const nested_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp new file mode 100644 index 00000000000..29d9eaeda4e --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp @@ -0,0 +1,530 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ + +#include "nested_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FirstStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FirstStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FirstStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FirstStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const SecondStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.first(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const SecondStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.first() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + SecondStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.first(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SecondStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ThirdStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.second(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ThirdStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.second() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + ThirdStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.second(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ThirdStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FourthStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.third(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FourthStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.third() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FourthStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.third(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FourthStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FifthStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.fourth(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FifthStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.fourth() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FifthStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.fourth(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FifthStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const nested_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.first(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.second(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.third(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.fourth(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.fifth(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const nested_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.first() + << eprosima::fastcdr::MemberId(1) << data.second() + << eprosima::fastcdr::MemberId(2) << data.third() + << eprosima::fastcdr::MemberId(3) << data.fourth() + << eprosima::fastcdr::MemberId(4) << data.fifth() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + nested_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.first(); + break; + + case 1: + dcdr >> data.second(); + break; + + case 2: + dcdr >> data.third(); + break; + + case 3: + dcdr >> data.fourth(); + break; + + case 4: + dcdr >> data.fifth(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const nested_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx new file mode 100644 index 00000000000..dbd9522d3a8 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx @@ -0,0 +1,1194 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "nested_structPubSubTypes.h" + +#include +#include + +#include "nested_structCdrAux.hpp" +#include "nested_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +FirstStructPubSubType::FirstStructPubSubType() +{ + setName("FirstStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FirstStruct::getMaxCdrSerializedSize()); +#else + FirstStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FirstStruct_max_key_cdr_typesize > 16 ? FirstStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FirstStructPubSubType::~FirstStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FirstStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FirstStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FirstStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FirstStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FirstStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FirstStructPubSubType::createData() +{ + return reinterpret_cast(new FirstStruct()); +} + +void FirstStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FirstStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FirstStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FirstStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FirstStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FirstStructPubSubType::register_type_object_representation() +{ + register_FirstStruct_type_identifier(type_identifiers_); +} + +SecondStructPubSubType::SecondStructPubSubType() +{ + setName("SecondStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(SecondStruct::getMaxCdrSerializedSize()); +#else + SecondStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = SecondStruct_max_key_cdr_typesize > 16 ? SecondStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +SecondStructPubSubType::~SecondStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool SecondStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + SecondStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool SecondStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + SecondStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function SecondStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* SecondStructPubSubType::createData() +{ + return reinterpret_cast(new SecondStruct()); +} + +void SecondStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool SecondStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + SecondStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + SecondStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || SecondStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void SecondStructPubSubType::register_type_object_representation() +{ + register_SecondStruct_type_identifier(type_identifiers_); +} + +ThirdStructPubSubType::ThirdStructPubSubType() +{ + setName("ThirdStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(ThirdStruct::getMaxCdrSerializedSize()); +#else + ThirdStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = ThirdStruct_max_key_cdr_typesize > 16 ? ThirdStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +ThirdStructPubSubType::~ThirdStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool ThirdStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + ThirdStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool ThirdStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + ThirdStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function ThirdStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* ThirdStructPubSubType::createData() +{ + return reinterpret_cast(new ThirdStruct()); +} + +void ThirdStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool ThirdStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + ThirdStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + ThirdStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || ThirdStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void ThirdStructPubSubType::register_type_object_representation() +{ + register_ThirdStruct_type_identifier(type_identifiers_); +} + +FourthStructPubSubType::FourthStructPubSubType() +{ + setName("FourthStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FourthStruct::getMaxCdrSerializedSize()); +#else + FourthStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FourthStruct_max_key_cdr_typesize > 16 ? FourthStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FourthStructPubSubType::~FourthStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FourthStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FourthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FourthStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FourthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FourthStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FourthStructPubSubType::createData() +{ + return reinterpret_cast(new FourthStruct()); +} + +void FourthStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FourthStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FourthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FourthStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FourthStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FourthStructPubSubType::register_type_object_representation() +{ + register_FourthStruct_type_identifier(type_identifiers_); +} + +FifthStructPubSubType::FifthStructPubSubType() +{ + setName("FifthStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FifthStruct::getMaxCdrSerializedSize()); +#else + FifthStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FifthStruct_max_key_cdr_typesize > 16 ? FifthStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FifthStructPubSubType::~FifthStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FifthStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FifthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FifthStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FifthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FifthStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FifthStructPubSubType::createData() +{ + return reinterpret_cast(new FifthStruct()); +} + +void FifthStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FifthStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FifthStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FifthStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FifthStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FifthStructPubSubType::register_type_object_representation() +{ + register_FifthStruct_type_identifier(type_identifiers_); +} + +nested_structPubSubType::nested_structPubSubType() +{ + setName("nested_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(nested_struct::getMaxCdrSerializedSize()); +#else + nested_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = nested_struct_max_key_cdr_typesize > 16 ? nested_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +nested_structPubSubType::~nested_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool nested_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + nested_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool nested_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + nested_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function nested_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* nested_structPubSubType::createData() +{ + return reinterpret_cast(new nested_struct()); +} + +void nested_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool nested_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + nested_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + nested_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || nested_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void nested_structPubSubType::register_type_object_representation() +{ + register_nested_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "nested_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h new file mode 100644 index 00000000000..e523eb63521 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h @@ -0,0 +1,588 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "nested_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated nested_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type FirstStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FirstStruct type; + + eProsima_user_DllExport FirstStructPubSubType(); + + eProsima_user_DllExport ~FirstStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type SecondStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef SecondStruct type; + + eProsima_user_DllExport SecondStructPubSubType(); + + eProsima_user_DllExport ~SecondStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type ThirdStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef ThirdStruct type; + + eProsima_user_DllExport ThirdStructPubSubType(); + + eProsima_user_DllExport ~ThirdStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type FourthStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FourthStruct type; + + eProsima_user_DllExport FourthStructPubSubType(); + + eProsima_user_DllExport ~FourthStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type FifthStruct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FifthStruct type; + + eProsima_user_DllExport FifthStructPubSubType(); + + eProsima_user_DllExport ~FifthStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type nested_struct defined by the user in the IDL file. + * @ingroup nested_struct + */ +class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef nested_struct type; + + eProsima_user_DllExport nested_structPubSubType(); + + eProsima_user_DllExport ~nested_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..25e48396516 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx @@ -0,0 +1,497 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "nested_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "nested_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FirstStruct_type_identifier( + TypeIdentifierPair& type_ids_FirstStruct) +{ + + ReturnCode_t return_code_FirstStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FirstStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FirstStruct", type_ids_FirstStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FirstStruct) + { + StructTypeFlag struct_flags_FirstStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_FirstStruct = "FirstStruct"; + eprosima::fastcdr::optional type_ann_builtin_FirstStruct; + eprosima::fastcdr::optional ann_custom_FirstStruct; + CompleteTypeDetail detail_FirstStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FirstStruct, ann_custom_FirstStruct, type_name_FirstStruct.to_string()); + CompleteStructHeader header_FirstStruct; + header_FirstStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FirstStruct); + CompleteStructMemberSeq member_seq_FirstStruct; + { + TypeIdentifierPair type_ids_value; + ReturnCode_t return_code_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_value = 0x00000000; + bool common_value_ec {false}; + CommonStructMember common_value {TypeObjectUtils::build_common_struct_member(member_id_value, member_flags_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_value, common_value_ec))}; + if (!common_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure value member TypeIdentifier inconsistent."); + return; + } + MemberName name_value = "value"; + eprosima::fastcdr::optional member_ann_builtin_value; + ann_custom_FirstStruct.reset(); + CompleteMemberDetail detail_value = TypeObjectUtils::build_complete_member_detail(name_value, member_ann_builtin_value, ann_custom_FirstStruct); + CompleteStructMember member_value = TypeObjectUtils::build_complete_struct_member(common_value, detail_value); + TypeObjectUtils::add_complete_struct_member(member_seq_FirstStruct, member_value); + } + CompleteStructType struct_type_FirstStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FirstStruct, header_FirstStruct, member_seq_FirstStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FirstStruct, type_name_FirstStruct.to_string(), type_ids_FirstStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FirstStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_SecondStruct_type_identifier( + TypeIdentifierPair& type_ids_SecondStruct) +{ + + ReturnCode_t return_code_SecondStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_SecondStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SecondStruct", type_ids_SecondStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_SecondStruct) + { + StructTypeFlag struct_flags_SecondStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_SecondStruct = "SecondStruct"; + eprosima::fastcdr::optional type_ann_builtin_SecondStruct; + eprosima::fastcdr::optional ann_custom_SecondStruct; + CompleteTypeDetail detail_SecondStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SecondStruct, ann_custom_SecondStruct, type_name_SecondStruct.to_string()); + CompleteStructHeader header_SecondStruct; + header_SecondStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SecondStruct); + CompleteStructMemberSeq member_seq_SecondStruct; + { + TypeIdentifierPair type_ids_first; + ReturnCode_t return_code_first {eprosima::fastdds::dds::RETCODE_OK}; + return_code_first = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FirstStruct", type_ids_first); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_first) + { + ::register_FirstStruct_type_identifier(type_ids_first); + } + StructMemberFlag member_flags_first = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_first = 0x00000000; + bool common_first_ec {false}; + CommonStructMember common_first {TypeObjectUtils::build_common_struct_member(member_id_first, member_flags_first, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_first, common_first_ec))}; + if (!common_first_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure first member TypeIdentifier inconsistent."); + return; + } + MemberName name_first = "first"; + eprosima::fastcdr::optional member_ann_builtin_first; + ann_custom_SecondStruct.reset(); + CompleteMemberDetail detail_first = TypeObjectUtils::build_complete_member_detail(name_first, member_ann_builtin_first, ann_custom_SecondStruct); + CompleteStructMember member_first = TypeObjectUtils::build_complete_struct_member(common_first, detail_first); + TypeObjectUtils::add_complete_struct_member(member_seq_SecondStruct, member_first); + } + CompleteStructType struct_type_SecondStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_SecondStruct, header_SecondStruct, member_seq_SecondStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_SecondStruct, type_name_SecondStruct.to_string(), type_ids_SecondStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "SecondStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ThirdStruct_type_identifier( + TypeIdentifierPair& type_ids_ThirdStruct) +{ + + ReturnCode_t return_code_ThirdStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ThirdStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdStruct", type_ids_ThirdStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ThirdStruct) + { + StructTypeFlag struct_flags_ThirdStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ThirdStruct = "ThirdStruct"; + eprosima::fastcdr::optional type_ann_builtin_ThirdStruct; + eprosima::fastcdr::optional ann_custom_ThirdStruct; + CompleteTypeDetail detail_ThirdStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ThirdStruct, ann_custom_ThirdStruct, type_name_ThirdStruct.to_string()); + CompleteStructHeader header_ThirdStruct; + header_ThirdStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ThirdStruct); + CompleteStructMemberSeq member_seq_ThirdStruct; + { + TypeIdentifierPair type_ids_second; + ReturnCode_t return_code_second {eprosima::fastdds::dds::RETCODE_OK}; + return_code_second = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SecondStruct", type_ids_second); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_second) + { + ::register_SecondStruct_type_identifier(type_ids_second); + } + StructMemberFlag member_flags_second = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_second = 0x00000000; + bool common_second_ec {false}; + CommonStructMember common_second {TypeObjectUtils::build_common_struct_member(member_id_second, member_flags_second, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_second, common_second_ec))}; + if (!common_second_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure second member TypeIdentifier inconsistent."); + return; + } + MemberName name_second = "second"; + eprosima::fastcdr::optional member_ann_builtin_second; + ann_custom_ThirdStruct.reset(); + CompleteMemberDetail detail_second = TypeObjectUtils::build_complete_member_detail(name_second, member_ann_builtin_second, ann_custom_ThirdStruct); + CompleteStructMember member_second = TypeObjectUtils::build_complete_struct_member(common_second, detail_second); + TypeObjectUtils::add_complete_struct_member(member_seq_ThirdStruct, member_second); + } + CompleteStructType struct_type_ThirdStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ThirdStruct, header_ThirdStruct, member_seq_ThirdStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ThirdStruct, type_name_ThirdStruct.to_string(), type_ids_ThirdStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ThirdStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FourthStruct_type_identifier( + TypeIdentifierPair& type_ids_FourthStruct) +{ + + ReturnCode_t return_code_FourthStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FourthStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FourthStruct", type_ids_FourthStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FourthStruct) + { + StructTypeFlag struct_flags_FourthStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_FourthStruct = "FourthStruct"; + eprosima::fastcdr::optional type_ann_builtin_FourthStruct; + eprosima::fastcdr::optional ann_custom_FourthStruct; + CompleteTypeDetail detail_FourthStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FourthStruct, ann_custom_FourthStruct, type_name_FourthStruct.to_string()); + CompleteStructHeader header_FourthStruct; + header_FourthStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FourthStruct); + CompleteStructMemberSeq member_seq_FourthStruct; + { + TypeIdentifierPair type_ids_third; + ReturnCode_t return_code_third {eprosima::fastdds::dds::RETCODE_OK}; + return_code_third = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdStruct", type_ids_third); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_third) + { + ::register_ThirdStruct_type_identifier(type_ids_third); + } + StructMemberFlag member_flags_third = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_third = 0x00000000; + bool common_third_ec {false}; + CommonStructMember common_third {TypeObjectUtils::build_common_struct_member(member_id_third, member_flags_third, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_third, common_third_ec))}; + if (!common_third_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure third member TypeIdentifier inconsistent."); + return; + } + MemberName name_third = "third"; + eprosima::fastcdr::optional member_ann_builtin_third; + ann_custom_FourthStruct.reset(); + CompleteMemberDetail detail_third = TypeObjectUtils::build_complete_member_detail(name_third, member_ann_builtin_third, ann_custom_FourthStruct); + CompleteStructMember member_third = TypeObjectUtils::build_complete_struct_member(common_third, detail_third); + TypeObjectUtils::add_complete_struct_member(member_seq_FourthStruct, member_third); + } + CompleteStructType struct_type_FourthStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FourthStruct, header_FourthStruct, member_seq_FourthStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FourthStruct, type_name_FourthStruct.to_string(), type_ids_FourthStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FourthStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FifthStruct_type_identifier( + TypeIdentifierPair& type_ids_FifthStruct) +{ + + ReturnCode_t return_code_FifthStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FifthStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FifthStruct", type_ids_FifthStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FifthStruct) + { + StructTypeFlag struct_flags_FifthStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_FifthStruct = "FifthStruct"; + eprosima::fastcdr::optional type_ann_builtin_FifthStruct; + eprosima::fastcdr::optional ann_custom_FifthStruct; + CompleteTypeDetail detail_FifthStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FifthStruct, ann_custom_FifthStruct, type_name_FifthStruct.to_string()); + CompleteStructHeader header_FifthStruct; + header_FifthStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FifthStruct); + CompleteStructMemberSeq member_seq_FifthStruct; + { + TypeIdentifierPair type_ids_fourth; + ReturnCode_t return_code_fourth {eprosima::fastdds::dds::RETCODE_OK}; + return_code_fourth = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FourthStruct", type_ids_fourth); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_fourth) + { + ::register_FourthStruct_type_identifier(type_ids_fourth); + } + StructMemberFlag member_flags_fourth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_fourth = 0x00000000; + bool common_fourth_ec {false}; + CommonStructMember common_fourth {TypeObjectUtils::build_common_struct_member(member_id_fourth, member_flags_fourth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fourth, common_fourth_ec))}; + if (!common_fourth_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fourth member TypeIdentifier inconsistent."); + return; + } + MemberName name_fourth = "fourth"; + eprosima::fastcdr::optional member_ann_builtin_fourth; + ann_custom_FifthStruct.reset(); + CompleteMemberDetail detail_fourth = TypeObjectUtils::build_complete_member_detail(name_fourth, member_ann_builtin_fourth, ann_custom_FifthStruct); + CompleteStructMember member_fourth = TypeObjectUtils::build_complete_struct_member(common_fourth, detail_fourth); + TypeObjectUtils::add_complete_struct_member(member_seq_FifthStruct, member_fourth); + } + CompleteStructType struct_type_FifthStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FifthStruct, header_FifthStruct, member_seq_FifthStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FifthStruct, type_name_FifthStruct.to_string(), type_ids_FifthStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FifthStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_nested_struct_type_identifier( + TypeIdentifierPair& type_ids_nested_struct) +{ + + ReturnCode_t return_code_nested_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_nested_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "nested_struct", type_ids_nested_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_nested_struct) + { + StructTypeFlag struct_flags_nested_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_nested_struct = "nested_struct"; + eprosima::fastcdr::optional type_ann_builtin_nested_struct; + eprosima::fastcdr::optional ann_custom_nested_struct; + CompleteTypeDetail detail_nested_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_nested_struct, ann_custom_nested_struct, type_name_nested_struct.to_string()); + CompleteStructHeader header_nested_struct; + header_nested_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_nested_struct); + CompleteStructMemberSeq member_seq_nested_struct; + { + TypeIdentifierPair type_ids_first; + ReturnCode_t return_code_first {eprosima::fastdds::dds::RETCODE_OK}; + return_code_first = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FirstStruct", type_ids_first); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_first) + { + ::register_FirstStruct_type_identifier(type_ids_first); + } + StructMemberFlag member_flags_first = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_first = 0x00000000; + bool common_first_ec {false}; + CommonStructMember common_first {TypeObjectUtils::build_common_struct_member(member_id_first, member_flags_first, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_first, common_first_ec))}; + if (!common_first_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure first member TypeIdentifier inconsistent."); + return; + } + MemberName name_first = "first"; + eprosima::fastcdr::optional member_ann_builtin_first; + ann_custom_nested_struct.reset(); + CompleteMemberDetail detail_first = TypeObjectUtils::build_complete_member_detail(name_first, member_ann_builtin_first, ann_custom_nested_struct); + CompleteStructMember member_first = TypeObjectUtils::build_complete_struct_member(common_first, detail_first); + TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_first); + } + { + TypeIdentifierPair type_ids_second; + ReturnCode_t return_code_second {eprosima::fastdds::dds::RETCODE_OK}; + return_code_second = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SecondStruct", type_ids_second); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_second) + { + ::register_SecondStruct_type_identifier(type_ids_second); + } + StructMemberFlag member_flags_second = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_second = 0x00000001; + bool common_second_ec {false}; + CommonStructMember common_second {TypeObjectUtils::build_common_struct_member(member_id_second, member_flags_second, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_second, common_second_ec))}; + if (!common_second_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure second member TypeIdentifier inconsistent."); + return; + } + MemberName name_second = "second"; + eprosima::fastcdr::optional member_ann_builtin_second; + ann_custom_nested_struct.reset(); + CompleteMemberDetail detail_second = TypeObjectUtils::build_complete_member_detail(name_second, member_ann_builtin_second, ann_custom_nested_struct); + CompleteStructMember member_second = TypeObjectUtils::build_complete_struct_member(common_second, detail_second); + TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_second); + } + { + TypeIdentifierPair type_ids_third; + ReturnCode_t return_code_third {eprosima::fastdds::dds::RETCODE_OK}; + return_code_third = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ThirdStruct", type_ids_third); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_third) + { + ::register_ThirdStruct_type_identifier(type_ids_third); + } + StructMemberFlag member_flags_third = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_third = 0x00000002; + bool common_third_ec {false}; + CommonStructMember common_third {TypeObjectUtils::build_common_struct_member(member_id_third, member_flags_third, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_third, common_third_ec))}; + if (!common_third_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure third member TypeIdentifier inconsistent."); + return; + } + MemberName name_third = "third"; + eprosima::fastcdr::optional member_ann_builtin_third; + ann_custom_nested_struct.reset(); + CompleteMemberDetail detail_third = TypeObjectUtils::build_complete_member_detail(name_third, member_ann_builtin_third, ann_custom_nested_struct); + CompleteStructMember member_third = TypeObjectUtils::build_complete_struct_member(common_third, detail_third); + TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_third); + } + { + TypeIdentifierPair type_ids_fourth; + ReturnCode_t return_code_fourth {eprosima::fastdds::dds::RETCODE_OK}; + return_code_fourth = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FourthStruct", type_ids_fourth); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_fourth) + { + ::register_FourthStruct_type_identifier(type_ids_fourth); + } + StructMemberFlag member_flags_fourth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_fourth = 0x00000003; + bool common_fourth_ec {false}; + CommonStructMember common_fourth {TypeObjectUtils::build_common_struct_member(member_id_fourth, member_flags_fourth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fourth, common_fourth_ec))}; + if (!common_fourth_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fourth member TypeIdentifier inconsistent."); + return; + } + MemberName name_fourth = "fourth"; + eprosima::fastcdr::optional member_ann_builtin_fourth; + ann_custom_nested_struct.reset(); + CompleteMemberDetail detail_fourth = TypeObjectUtils::build_complete_member_detail(name_fourth, member_ann_builtin_fourth, ann_custom_nested_struct); + CompleteStructMember member_fourth = TypeObjectUtils::build_complete_struct_member(common_fourth, detail_fourth); + TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_fourth); + } + { + TypeIdentifierPair type_ids_fifth; + ReturnCode_t return_code_fifth {eprosima::fastdds::dds::RETCODE_OK}; + return_code_fifth = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FifthStruct", type_ids_fifth); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_fifth) + { + ::register_FifthStruct_type_identifier(type_ids_fifth); + } + StructMemberFlag member_flags_fifth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_fifth = 0x00000004; + bool common_fifth_ec {false}; + CommonStructMember common_fifth {TypeObjectUtils::build_common_struct_member(member_id_fifth, member_flags_fifth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fifth, common_fifth_ec))}; + if (!common_fifth_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fifth member TypeIdentifier inconsistent."); + return; + } + MemberName name_fifth = "fifth"; + eprosima::fastcdr::optional member_ann_builtin_fifth; + ann_custom_nested_struct.reset(); + CompleteMemberDetail detail_fifth = TypeObjectUtils::build_complete_member_detail(name_fifth, member_ann_builtin_fifth, ann_custom_nested_struct); + CompleteStructMember member_fifth = TypeObjectUtils::build_complete_struct_member(common_fifth, detail_fifth); + TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_fifth); + } + CompleteStructType struct_type_nested_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_nested_struct, header_nested_struct, member_seq_nested_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_nested_struct, type_name_nested_struct.to_string(), type_ids_nested_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "nested_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..313def76200 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp @@ -0,0 +1,116 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file nested_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register FirstStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FirstStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register SecondStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_SecondStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register ThirdStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ThirdStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register FourthStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FourthStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register FifthStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FifthStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register nested_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_nested_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From 30f9e1aca16cd5e6c58a3c03f48d8c382fd35696 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 15:10:20 +0200 Subject: [PATCH 33/52] Support inheritance in TK_STRUCT Signed-off-by: tempate --- .../xtypes/type_conversion/dyn_type_tree.hpp | 3 + .../xtypes/type_conversion/dyn_type_tree.ipp | 90 ++++++++++++++++--- 2 files changed, 82 insertions(+), 11 deletions(-) diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp index d9110d599a2..02ce801bfc6 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp @@ -44,10 +44,12 @@ struct TreeNodeType const std::string& member_name, const std::string& type_kind_name, const DynamicType::_ref_type& dynamic_type, + const bool is_base = false, const bool is_key = false) : member_name(member_name) , type_kind_name(type_kind_name) , dynamic_type(dynamic_type) + , is_base(is_base) , is_key(is_key) { } @@ -55,6 +57,7 @@ struct TreeNodeType std::string member_name; std::string type_kind_name; DynamicType::_ref_type dynamic_type; + bool is_base; bool is_key; }; diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp index 9b36eb524c2..b98c8622456 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp @@ -53,6 +53,34 @@ ReturnCode_t dyn_type_to_tree( // Create new tree node utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); + // Get its base class + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = type->get_descriptor(type_descriptor); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Add base class as a new branch + const auto base_type = type_descriptor->base_type(); + + if (base_type != nullptr) + { + utilities::collections::TreeNode child; + ret = dyn_type_to_tree(base_type, "PARENT", child); + + if (ret != RETCODE_OK) + { + return ret; + } + + child.info.is_base = true; + + // Add each member with its name as a new child in a branch (recursion) + parent.add_branch(child); + } + // Get all members of this struct std::vector> members_by_name; ret = get_members_sorted(type, members_by_name); @@ -246,12 +274,12 @@ ReturnCode_t type_kind_to_str( ret = map_kind_to_str(dyn_type, type_str); break; } - case TK_STRUCTURE: + case TK_ALIAS: + case TK_BITMASK: + case TK_BITSET: case TK_ENUM: + case TK_STRUCTURE: case TK_UNION: - case TK_BITSET: - case TK_BITMASK: - case TK_ALIAS: { type_str = dyn_type->get_name().to_string(); break; @@ -421,28 +449,47 @@ ReturnCode_t get_members_sorted( { ReturnCode_t ret = RETCODE_OK; - std::map members; - ret = dyn_type->get_all_members(members); + // Skip the inherited members + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = dyn_type->get_descriptor(type_descriptor); if (ret != RETCODE_OK) { return ret; } - for (const auto& member : members) + const auto base_type = type_descriptor->base_type(); + + std::uint32_t first_member = 0; + + if (base_type != nullptr) { + // If the struct has a base type, the first member is the base type + first_member = base_type->get_member_count(); + } + + // Collect its members + for (std::uint32_t index = first_member; index < dyn_type->get_member_count(); index++) + { + traits::ref_type member; + ret = dyn_type->get_member_by_index(member, index); + + if (ret != RETCODE_OK) + { + return ret; + } + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member.second->get_descriptor(member_descriptor); + ret = member->get_descriptor(member_descriptor); if (ret != RETCODE_OK) { return ret; } - const auto dyn_name = member.second->get_name(); result.emplace_back( std::make_pair( - dyn_name.to_string(), + member_descriptor->name().to_string(), std::move(member_descriptor))); } @@ -875,11 +922,32 @@ ReturnCode_t struct_to_str( } // Add types name - struct_str += "struct " + node.info.type_kind_name + TYPE_OPENING; + struct_str += "struct " + node.info.type_kind_name; + + // Add inheritance + if (type_descriptor->base_type() != nullptr) + { + std::string base_type_str; + ret = type_kind_to_str(type_descriptor->base_type(), base_type_str); + + if (ret != RETCODE_OK) + { + return ret; + } + + struct_str += " : " + base_type_str; + } + + struct_str += TYPE_OPENING; // Add struct attributes for (auto const& child : node.branches()) { + if (child.info.is_base) + { + continue; + } + std::string child_str; node_to_str(child.info, child_str); From 2e4da04ea43b2b3fdbd05fe3a8b6a2d4854dc408 Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 25 Jun 2024 15:11:20 +0200 Subject: [PATCH 34/52] Tests - Inheritance in TK_STRUCT Signed-off-by: tempate --- .../dds/xtypes/type_conversion/CMakeLists.txt | 4 + .../type_conversion/types/all_types.hpp | 8 + .../types/idls/inheritance_struct.idl | 29 + .../inheritance_struct/inheritance_struct.hpp | 843 ++++++++++++ .../inheritance_structCdrAux.hpp | 81 ++ .../inheritance_structCdrAux.ipp | 618 +++++++++ .../inheritance_structPubSubTypes.cxx | 1194 +++++++++++++++++ .../inheritance_structPubSubTypes.h | 588 ++++++++ .../inheritance_structTypeObjectSupport.cxx | 500 +++++++ .../inheritance_structTypeObjectSupport.hpp | 116 ++ 10 files changed, 3981 insertions(+) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt index 7471d1e113e..09915c3fd7a 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt @@ -44,6 +44,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/complex_nested_arrays.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/complex_nested_arrays.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/inheritance_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/inheritance_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/enum_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/enum_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index e6578e76ad6..dc9864957bd 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -56,6 +56,9 @@ #include "type_objects/hello_world/hello_world.hpp" #include "type_objects/hello_world/hello_worldPubSubTypes.h" +#include "type_objects/inheritance_struct/inheritance_struct.hpp" +#include "type_objects/inheritance_struct/inheritance_structPubSubTypes.h" + #include "type_objects/key_struct/key_struct.hpp" #include "type_objects/key_struct/key_structPubSubTypes.h" @@ -87,6 +90,7 @@ const std::string ENUM_STRUCT{"enum_struct"}; const std::string EXTENSIBILITY_STRUCT{"extensibility_struct"}; const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; const std::string HELLO_WORLD{"hello_world"}; +const std::string INHERITANCE_STRUCT{"inheritance_struct"}; const std::string KEY_STRUCT{"key_struct"}; const std::string MAP_STRUCT{"map_struct"}; const std::string NESTED_STRUCT{"nested_struct"}; @@ -108,6 +112,7 @@ const std::vector supported_types = { SupportedTypes::EXTENSIBILITY_STRUCT, SupportedTypes::FLOAT_BOUNDED_SEQUENCE, SupportedTypes::HELLO_WORLD, + SupportedTypes::INHERITANCE_STRUCT, SupportedTypes::KEY_STRUCT, SupportedTypes::MAP_STRUCT, SupportedTypes::NESTED_STRUCT, @@ -155,6 +160,9 @@ void register_dynamic_types() TypeSupport type_hello_world(new hello_worldPubSubType()); type_hello_world->register_type_object_representation(); + TypeSupport type_inheritance_struct(new inheritance_structPubSubType()); + type_inheritance_struct->register_type_object_representation(); + TypeSupport type_key_struct(new key_structPubSubType()); type_key_struct->register_type_object_representation(); diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl b/test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl new file mode 100644 index 00000000000..c4a52662b4d --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl @@ -0,0 +1,29 @@ +struct GreatgrandfatherStruct +{ + long greatgrandfather; +}; + +struct GrandfatherStruct : GreatgrandfatherStruct +{ + long grandfather; +}; + +struct FatherStruct : GrandfatherStruct +{ + long father; +}; + +struct SonStruct : FatherStruct +{ + long son; +}; + +struct GrandsonStruct : SonStruct +{ + long grandson; +}; + +struct inheritance_struct : GrandsonStruct +{ + long value; +}; diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp new file mode 100644 index 00000000000..6d475fde287 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp @@ -0,0 +1,843 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ +#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(INHERITANCE_STRUCT_SOURCE) +#define INHERITANCE_STRUCT_DllAPI __declspec( dllexport ) +#else +#define INHERITANCE_STRUCT_DllAPI __declspec( dllimport ) +#endif // INHERITANCE_STRUCT_SOURCE +#else +#define INHERITANCE_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define INHERITANCE_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure GreatgrandfatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GreatgrandfatherStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport GreatgrandfatherStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~GreatgrandfatherStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object GreatgrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GreatgrandfatherStruct( + const GreatgrandfatherStruct& x) + { + m_greatgrandfather = x.m_greatgrandfather; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object GreatgrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GreatgrandfatherStruct( + GreatgrandfatherStruct&& x) noexcept + { + m_greatgrandfather = x.m_greatgrandfather; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object GreatgrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GreatgrandfatherStruct& operator =( + const GreatgrandfatherStruct& x) + { + + m_greatgrandfather = x.m_greatgrandfather; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object GreatgrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GreatgrandfatherStruct& operator =( + GreatgrandfatherStruct&& x) noexcept + { + + m_greatgrandfather = x.m_greatgrandfather; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x GreatgrandfatherStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const GreatgrandfatherStruct& x) const + { + return (m_greatgrandfather == x.m_greatgrandfather); + } + + /*! + * @brief Comparison operator. + * @param x GreatgrandfatherStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const GreatgrandfatherStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member greatgrandfather + * @param _greatgrandfather New value for member greatgrandfather + */ + eProsima_user_DllExport void greatgrandfather( + int32_t _greatgrandfather) + { + m_greatgrandfather = _greatgrandfather; + } + + /*! + * @brief This function returns the value of member greatgrandfather + * @return Value of member greatgrandfather + */ + eProsima_user_DllExport int32_t greatgrandfather() const + { + return m_greatgrandfather; + } + + /*! + * @brief This function returns a reference to member greatgrandfather + * @return Reference to member greatgrandfather + */ + eProsima_user_DllExport int32_t& greatgrandfather() + { + return m_greatgrandfather; + } + + + +private: + + int32_t m_greatgrandfather{0}; + +}; +/*! + * @brief This class represents the structure GrandfatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GrandfatherStruct : public GreatgrandfatherStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport GrandfatherStruct() + : GreatgrandfatherStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~GrandfatherStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object GrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GrandfatherStruct( + const GrandfatherStruct& x) + : GreatgrandfatherStruct(x) + { + m_grandfather = x.m_grandfather; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object GrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GrandfatherStruct( + GrandfatherStruct&& x) noexcept + : GreatgrandfatherStruct(std::move(x)) + + { + m_grandfather = x.m_grandfather; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object GrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GrandfatherStruct& operator =( + const GrandfatherStruct& x) + { + GreatgrandfatherStruct::operator =(x); + + m_grandfather = x.m_grandfather; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object GrandfatherStruct that will be copied. + */ + eProsima_user_DllExport GrandfatherStruct& operator =( + GrandfatherStruct&& x) noexcept + { + GreatgrandfatherStruct::operator =(std::move(x)); + + m_grandfather = x.m_grandfather; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x GrandfatherStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const GrandfatherStruct& x) const + { + if (GreatgrandfatherStruct::operator !=(x)) + { + return false; + } + return (m_grandfather == x.m_grandfather); + } + + /*! + * @brief Comparison operator. + * @param x GrandfatherStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const GrandfatherStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member grandfather + * @param _grandfather New value for member grandfather + */ + eProsima_user_DllExport void grandfather( + int32_t _grandfather) + { + m_grandfather = _grandfather; + } + + /*! + * @brief This function returns the value of member grandfather + * @return Value of member grandfather + */ + eProsima_user_DllExport int32_t grandfather() const + { + return m_grandfather; + } + + /*! + * @brief This function returns a reference to member grandfather + * @return Reference to member grandfather + */ + eProsima_user_DllExport int32_t& grandfather() + { + return m_grandfather; + } + + + +private: + + int32_t m_grandfather{0}; + +}; +/*! + * @brief This class represents the structure FatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class FatherStruct : public GrandfatherStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport FatherStruct() + : GrandfatherStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~FatherStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object FatherStruct that will be copied. + */ + eProsima_user_DllExport FatherStruct( + const FatherStruct& x) + : GrandfatherStruct(x) + { + m_father = x.m_father; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object FatherStruct that will be copied. + */ + eProsima_user_DllExport FatherStruct( + FatherStruct&& x) noexcept + : GrandfatherStruct(std::move(x)) + + { + m_father = x.m_father; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object FatherStruct that will be copied. + */ + eProsima_user_DllExport FatherStruct& operator =( + const FatherStruct& x) + { + GrandfatherStruct::operator =(x); + + m_father = x.m_father; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object FatherStruct that will be copied. + */ + eProsima_user_DllExport FatherStruct& operator =( + FatherStruct&& x) noexcept + { + GrandfatherStruct::operator =(std::move(x)); + + m_father = x.m_father; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x FatherStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const FatherStruct& x) const + { + if (GrandfatherStruct::operator !=(x)) + { + return false; + } + return (m_father == x.m_father); + } + + /*! + * @brief Comparison operator. + * @param x FatherStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const FatherStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member father + * @param _father New value for member father + */ + eProsima_user_DllExport void father( + int32_t _father) + { + m_father = _father; + } + + /*! + * @brief This function returns the value of member father + * @return Value of member father + */ + eProsima_user_DllExport int32_t father() const + { + return m_father; + } + + /*! + * @brief This function returns a reference to member father + * @return Reference to member father + */ + eProsima_user_DllExport int32_t& father() + { + return m_father; + } + + + +private: + + int32_t m_father{0}; + +}; +/*! + * @brief This class represents the structure SonStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class SonStruct : public FatherStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport SonStruct() + : FatherStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~SonStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object SonStruct that will be copied. + */ + eProsima_user_DllExport SonStruct( + const SonStruct& x) + : FatherStruct(x) + { + m_son = x.m_son; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object SonStruct that will be copied. + */ + eProsima_user_DllExport SonStruct( + SonStruct&& x) noexcept + : FatherStruct(std::move(x)) + + { + m_son = x.m_son; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object SonStruct that will be copied. + */ + eProsima_user_DllExport SonStruct& operator =( + const SonStruct& x) + { + FatherStruct::operator =(x); + + m_son = x.m_son; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object SonStruct that will be copied. + */ + eProsima_user_DllExport SonStruct& operator =( + SonStruct&& x) noexcept + { + FatherStruct::operator =(std::move(x)); + + m_son = x.m_son; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x SonStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const SonStruct& x) const + { + if (FatherStruct::operator !=(x)) + { + return false; + } + return (m_son == x.m_son); + } + + /*! + * @brief Comparison operator. + * @param x SonStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const SonStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member son + * @param _son New value for member son + */ + eProsima_user_DllExport void son( + int32_t _son) + { + m_son = _son; + } + + /*! + * @brief This function returns the value of member son + * @return Value of member son + */ + eProsima_user_DllExport int32_t son() const + { + return m_son; + } + + /*! + * @brief This function returns a reference to member son + * @return Reference to member son + */ + eProsima_user_DllExport int32_t& son() + { + return m_son; + } + + + +private: + + int32_t m_son{0}; + +}; +/*! + * @brief This class represents the structure GrandsonStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GrandsonStruct : public SonStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport GrandsonStruct() + : SonStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~GrandsonStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object GrandsonStruct that will be copied. + */ + eProsima_user_DllExport GrandsonStruct( + const GrandsonStruct& x) + : SonStruct(x) + { + m_grandson = x.m_grandson; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object GrandsonStruct that will be copied. + */ + eProsima_user_DllExport GrandsonStruct( + GrandsonStruct&& x) noexcept + : SonStruct(std::move(x)) + + { + m_grandson = x.m_grandson; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object GrandsonStruct that will be copied. + */ + eProsima_user_DllExport GrandsonStruct& operator =( + const GrandsonStruct& x) + { + SonStruct::operator =(x); + + m_grandson = x.m_grandson; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object GrandsonStruct that will be copied. + */ + eProsima_user_DllExport GrandsonStruct& operator =( + GrandsonStruct&& x) noexcept + { + SonStruct::operator =(std::move(x)); + + m_grandson = x.m_grandson; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x GrandsonStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const GrandsonStruct& x) const + { + if (SonStruct::operator !=(x)) + { + return false; + } + return (m_grandson == x.m_grandson); + } + + /*! + * @brief Comparison operator. + * @param x GrandsonStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const GrandsonStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member grandson + * @param _grandson New value for member grandson + */ + eProsima_user_DllExport void grandson( + int32_t _grandson) + { + m_grandson = _grandson; + } + + /*! + * @brief This function returns the value of member grandson + * @return Value of member grandson + */ + eProsima_user_DllExport int32_t grandson() const + { + return m_grandson; + } + + /*! + * @brief This function returns a reference to member grandson + * @return Reference to member grandson + */ + eProsima_user_DllExport int32_t& grandson() + { + return m_grandson; + } + + + +private: + + int32_t m_grandson{0}; + +}; +/*! + * @brief This class represents the structure inheritance_struct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class inheritance_struct : public GrandsonStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport inheritance_struct() + : GrandsonStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~inheritance_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object inheritance_struct that will be copied. + */ + eProsima_user_DllExport inheritance_struct( + const inheritance_struct& x) + : GrandsonStruct(x) + { + m_value = x.m_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object inheritance_struct that will be copied. + */ + eProsima_user_DllExport inheritance_struct( + inheritance_struct&& x) noexcept + : GrandsonStruct(std::move(x)) + + { + m_value = x.m_value; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object inheritance_struct that will be copied. + */ + eProsima_user_DllExport inheritance_struct& operator =( + const inheritance_struct& x) + { + GrandsonStruct::operator =(x); + + m_value = x.m_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object inheritance_struct that will be copied. + */ + eProsima_user_DllExport inheritance_struct& operator =( + inheritance_struct&& x) noexcept + { + GrandsonStruct::operator =(std::move(x)); + + m_value = x.m_value; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x inheritance_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const inheritance_struct& x) const + { + if (GrandsonStruct::operator !=(x)) + { + return false; + } + return (m_value == x.m_value); + } + + /*! + * @brief Comparison operator. + * @param x inheritance_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const inheritance_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member value + * @param _value New value for member value + */ + eProsima_user_DllExport void value( + int32_t _value) + { + m_value = _value; + } + + /*! + * @brief This function returns the value of member value + * @return Value of member value + */ + eProsima_user_DllExport int32_t value() const + { + return m_value; + } + + /*! + * @brief This function returns a reference to member value + * @return Reference to member value + */ + eProsima_user_DllExport int32_t& value() + { + return m_value; + } + + + +private: + + int32_t m_value{0}; + +}; + +#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp new file mode 100644 index 00000000000..7e91fa43e98 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp @@ -0,0 +1,81 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ +#define _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ + +#include "inheritance_struct.hpp" + +constexpr uint32_t GrandsonStruct_max_cdr_typesize {24UL}; +constexpr uint32_t GrandsonStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t GrandfatherStruct_max_cdr_typesize {12UL}; +constexpr uint32_t GrandfatherStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t FatherStruct_max_cdr_typesize {16UL}; +constexpr uint32_t FatherStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t inheritance_struct_max_cdr_typesize {28UL}; +constexpr uint32_t inheritance_struct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t SonStruct_max_cdr_typesize {20UL}; +constexpr uint32_t SonStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t GreatgrandfatherStruct_max_cdr_typesize {8UL}; +constexpr uint32_t GreatgrandfatherStruct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GreatgrandfatherStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GrandfatherStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FatherStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SonStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GrandsonStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const inheritance_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp new file mode 100644 index 00000000000..fab1a6a0c65 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp @@ -0,0 +1,618 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ +#define _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ + +#include "inheritance_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const GreatgrandfatherStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const GreatgrandfatherStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + GreatgrandfatherStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GreatgrandfatherStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const GrandfatherStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.grandfather(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const GrandfatherStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() + << eprosima::fastcdr::MemberId(1) << data.grandfather() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + GrandfatherStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + case 1: + dcdr >> data.grandfather(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GrandfatherStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const FatherStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.grandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.father(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const FatherStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() + << eprosima::fastcdr::MemberId(1) << data.grandfather() + << eprosima::fastcdr::MemberId(2) << data.father() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + FatherStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + case 1: + dcdr >> data.grandfather(); + break; + + case 2: + dcdr >> data.father(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const FatherStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const SonStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.grandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.father(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.son(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const SonStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() + << eprosima::fastcdr::MemberId(1) << data.grandfather() + << eprosima::fastcdr::MemberId(2) << data.father() + << eprosima::fastcdr::MemberId(3) << data.son() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + SonStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + case 1: + dcdr >> data.grandfather(); + break; + + case 2: + dcdr >> data.father(); + break; + + case 3: + dcdr >> data.son(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const SonStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const GrandsonStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.grandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.father(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.son(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.grandson(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const GrandsonStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() + << eprosima::fastcdr::MemberId(1) << data.grandfather() + << eprosima::fastcdr::MemberId(2) << data.father() + << eprosima::fastcdr::MemberId(3) << data.son() + << eprosima::fastcdr::MemberId(4) << data.grandson() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + GrandsonStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + case 1: + dcdr >> data.grandfather(); + break; + + case 2: + dcdr >> data.father(); + break; + + case 3: + dcdr >> data.son(); + break; + + case 4: + dcdr >> data.grandson(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const GrandsonStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const inheritance_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.greatgrandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.grandfather(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.father(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.son(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.grandson(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5), + data.value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const inheritance_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() + << eprosima::fastcdr::MemberId(1) << data.grandfather() + << eprosima::fastcdr::MemberId(2) << data.father() + << eprosima::fastcdr::MemberId(3) << data.son() + << eprosima::fastcdr::MemberId(4) << data.grandson() + << eprosima::fastcdr::MemberId(5) << data.value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + inheritance_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.greatgrandfather(); + break; + + case 1: + dcdr >> data.grandfather(); + break; + + case 2: + dcdr >> data.father(); + break; + + case 3: + dcdr >> data.son(); + break; + + case 4: + dcdr >> data.grandson(); + break; + + case 5: + dcdr >> data.value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const inheritance_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx new file mode 100644 index 00000000000..b8dfb4fcbc9 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx @@ -0,0 +1,1194 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "inheritance_structPubSubTypes.h" + +#include +#include + +#include "inheritance_structCdrAux.hpp" +#include "inheritance_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +GreatgrandfatherStructPubSubType::GreatgrandfatherStructPubSubType() +{ + setName("GreatgrandfatherStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(GreatgrandfatherStruct::getMaxCdrSerializedSize()); +#else + GreatgrandfatherStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = GreatgrandfatherStruct_max_key_cdr_typesize > 16 ? GreatgrandfatherStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +GreatgrandfatherStructPubSubType::~GreatgrandfatherStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool GreatgrandfatherStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + GreatgrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool GreatgrandfatherStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + GreatgrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function GreatgrandfatherStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* GreatgrandfatherStructPubSubType::createData() +{ + return reinterpret_cast(new GreatgrandfatherStruct()); +} + +void GreatgrandfatherStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool GreatgrandfatherStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + GreatgrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + GreatgrandfatherStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || GreatgrandfatherStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void GreatgrandfatherStructPubSubType::register_type_object_representation() +{ + register_GreatgrandfatherStruct_type_identifier(type_identifiers_); +} + +GrandfatherStructPubSubType::GrandfatherStructPubSubType() +{ + setName("GrandfatherStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(GrandfatherStruct::getMaxCdrSerializedSize()); +#else + GrandfatherStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = GrandfatherStruct_max_key_cdr_typesize > 16 ? GrandfatherStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +GrandfatherStructPubSubType::~GrandfatherStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool GrandfatherStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + GrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool GrandfatherStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + GrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function GrandfatherStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* GrandfatherStructPubSubType::createData() +{ + return reinterpret_cast(new GrandfatherStruct()); +} + +void GrandfatherStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool GrandfatherStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + GrandfatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + GrandfatherStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || GrandfatherStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void GrandfatherStructPubSubType::register_type_object_representation() +{ + register_GrandfatherStruct_type_identifier(type_identifiers_); +} + +FatherStructPubSubType::FatherStructPubSubType() +{ + setName("FatherStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(FatherStruct::getMaxCdrSerializedSize()); +#else + FatherStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = FatherStruct_max_key_cdr_typesize > 16 ? FatherStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +FatherStructPubSubType::~FatherStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool FatherStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + FatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool FatherStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + FatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function FatherStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* FatherStructPubSubType::createData() +{ + return reinterpret_cast(new FatherStruct()); +} + +void FatherStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool FatherStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + FatherStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + FatherStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || FatherStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void FatherStructPubSubType::register_type_object_representation() +{ + register_FatherStruct_type_identifier(type_identifiers_); +} + +SonStructPubSubType::SonStructPubSubType() +{ + setName("SonStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(SonStruct::getMaxCdrSerializedSize()); +#else + SonStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = SonStruct_max_key_cdr_typesize > 16 ? SonStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +SonStructPubSubType::~SonStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool SonStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + SonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool SonStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + SonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function SonStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* SonStructPubSubType::createData() +{ + return reinterpret_cast(new SonStruct()); +} + +void SonStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool SonStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + SonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + SonStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || SonStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void SonStructPubSubType::register_type_object_representation() +{ + register_SonStruct_type_identifier(type_identifiers_); +} + +GrandsonStructPubSubType::GrandsonStructPubSubType() +{ + setName("GrandsonStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(GrandsonStruct::getMaxCdrSerializedSize()); +#else + GrandsonStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = GrandsonStruct_max_key_cdr_typesize > 16 ? GrandsonStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +GrandsonStructPubSubType::~GrandsonStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool GrandsonStructPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + GrandsonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool GrandsonStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + GrandsonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function GrandsonStructPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* GrandsonStructPubSubType::createData() +{ + return reinterpret_cast(new GrandsonStruct()); +} + +void GrandsonStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool GrandsonStructPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + GrandsonStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + GrandsonStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || GrandsonStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void GrandsonStructPubSubType::register_type_object_representation() +{ + register_GrandsonStruct_type_identifier(type_identifiers_); +} + +inheritance_structPubSubType::inheritance_structPubSubType() +{ + setName("inheritance_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(inheritance_struct::getMaxCdrSerializedSize()); +#else + inheritance_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = inheritance_struct_max_key_cdr_typesize > 16 ? inheritance_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +inheritance_structPubSubType::~inheritance_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool inheritance_structPubSubType::serialize( + void* data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + inheritance_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool inheritance_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + inheritance_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function inheritance_structPubSubType::getSerializedSizeProvider( + void* data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* inheritance_structPubSubType::createData() +{ + return reinterpret_cast(new inheritance_struct()); +} + +void inheritance_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool inheritance_structPubSubType::getKey( + void* data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + inheritance_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + inheritance_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || inheritance_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void inheritance_structPubSubType::register_type_object_representation() +{ + register_inheritance_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "inheritance_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h new file mode 100644 index 00000000000..8a1b5a54e42 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h @@ -0,0 +1,588 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structPubSubTypes.h + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ +#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ + +#include +#include +#include +#include +#include + +#include "inheritance_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated inheritance_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type GreatgrandfatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef GreatgrandfatherStruct type; + + eProsima_user_DllExport GreatgrandfatherStructPubSubType(); + + eProsima_user_DllExport ~GreatgrandfatherStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type GrandfatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef GrandfatherStruct type; + + eProsima_user_DllExport GrandfatherStructPubSubType(); + + eProsima_user_DllExport ~GrandfatherStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type FatherStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef FatherStruct type; + + eProsima_user_DllExport FatherStructPubSubType(); + + eProsima_user_DllExport ~FatherStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type SonStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef SonStruct type; + + eProsima_user_DllExport SonStructPubSubType(); + + eProsima_user_DllExport ~SonStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type GrandsonStruct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef GrandsonStruct type; + + eProsima_user_DllExport GrandsonStructPubSubType(); + + eProsima_user_DllExport ~GrandsonStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type inheritance_struct defined by the user in the IDL file. + * @ingroup inheritance_struct + */ +class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef inheritance_struct type; + + eProsima_user_DllExport inheritance_structPubSubType(); + + eProsima_user_DllExport ~inheritance_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + void* data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + void* data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + void* data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..15d4c81f85a --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx @@ -0,0 +1,500 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "inheritance_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "inheritance_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_GreatgrandfatherStruct_type_identifier( + TypeIdentifierPair& type_ids_GreatgrandfatherStruct) +{ + + ReturnCode_t return_code_GreatgrandfatherStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_GreatgrandfatherStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GreatgrandfatherStruct", type_ids_GreatgrandfatherStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_GreatgrandfatherStruct) + { + StructTypeFlag struct_flags_GreatgrandfatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_GreatgrandfatherStruct = "GreatgrandfatherStruct"; + eprosima::fastcdr::optional type_ann_builtin_GreatgrandfatherStruct; + eprosima::fastcdr::optional ann_custom_GreatgrandfatherStruct; + CompleteTypeDetail detail_GreatgrandfatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GreatgrandfatherStruct, ann_custom_GreatgrandfatherStruct, type_name_GreatgrandfatherStruct.to_string()); + CompleteStructHeader header_GreatgrandfatherStruct; + header_GreatgrandfatherStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_GreatgrandfatherStruct); + CompleteStructMemberSeq member_seq_GreatgrandfatherStruct; + { + TypeIdentifierPair type_ids_greatgrandfather; + ReturnCode_t return_code_greatgrandfather {eprosima::fastdds::dds::RETCODE_OK}; + return_code_greatgrandfather = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_greatgrandfather); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_greatgrandfather) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "greatgrandfather Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_greatgrandfather = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_greatgrandfather = 0x00000000; + bool common_greatgrandfather_ec {false}; + CommonStructMember common_greatgrandfather {TypeObjectUtils::build_common_struct_member(member_id_greatgrandfather, member_flags_greatgrandfather, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_greatgrandfather, common_greatgrandfather_ec))}; + if (!common_greatgrandfather_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure greatgrandfather member TypeIdentifier inconsistent."); + return; + } + MemberName name_greatgrandfather = "greatgrandfather"; + eprosima::fastcdr::optional member_ann_builtin_greatgrandfather; + ann_custom_GreatgrandfatherStruct.reset(); + CompleteMemberDetail detail_greatgrandfather = TypeObjectUtils::build_complete_member_detail(name_greatgrandfather, member_ann_builtin_greatgrandfather, ann_custom_GreatgrandfatherStruct); + CompleteStructMember member_greatgrandfather = TypeObjectUtils::build_complete_struct_member(common_greatgrandfather, detail_greatgrandfather); + TypeObjectUtils::add_complete_struct_member(member_seq_GreatgrandfatherStruct, member_greatgrandfather); + } + CompleteStructType struct_type_GreatgrandfatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GreatgrandfatherStruct, header_GreatgrandfatherStruct, member_seq_GreatgrandfatherStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_GreatgrandfatherStruct, type_name_GreatgrandfatherStruct.to_string(), type_ids_GreatgrandfatherStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GreatgrandfatherStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_GrandfatherStruct_type_identifier( + TypeIdentifierPair& type_ids_GrandfatherStruct) +{ + + ReturnCode_t return_code_GrandfatherStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_GrandfatherStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandfatherStruct", type_ids_GrandfatherStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrandfatherStruct) + { + StructTypeFlag struct_flags_GrandfatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_GrandfatherStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GreatgrandfatherStruct", type_ids_GrandfatherStruct); + + if (return_code_GrandfatherStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_GreatgrandfatherStruct_type_identifier(type_ids_GrandfatherStruct); + } + QualifiedTypeName type_name_GrandfatherStruct = "GrandfatherStruct"; + eprosima::fastcdr::optional type_ann_builtin_GrandfatherStruct; + eprosima::fastcdr::optional ann_custom_GrandfatherStruct; + CompleteTypeDetail detail_GrandfatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GrandfatherStruct, ann_custom_GrandfatherStruct, type_name_GrandfatherStruct.to_string()); + CompleteStructHeader header_GrandfatherStruct; + if (EK_COMPLETE == type_ids_GrandfatherStruct.type_identifier1()._d()) + { + header_GrandfatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandfatherStruct.type_identifier1(), detail_GrandfatherStruct); + } + else if (EK_COMPLETE == type_ids_GrandfatherStruct.type_identifier2()._d()) + { + header_GrandfatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandfatherStruct.type_identifier2(), detail_GrandfatherStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GrandfatherStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_GrandfatherStruct; + { + TypeIdentifierPair type_ids_grandfather; + ReturnCode_t return_code_grandfather {eprosima::fastdds::dds::RETCODE_OK}; + return_code_grandfather = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_grandfather); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_grandfather) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "grandfather Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_grandfather = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_grandfather = 0x00000001; + bool common_grandfather_ec {false}; + CommonStructMember common_grandfather {TypeObjectUtils::build_common_struct_member(member_id_grandfather, member_flags_grandfather, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_grandfather, common_grandfather_ec))}; + if (!common_grandfather_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure grandfather member TypeIdentifier inconsistent."); + return; + } + MemberName name_grandfather = "grandfather"; + eprosima::fastcdr::optional member_ann_builtin_grandfather; + ann_custom_GrandfatherStruct.reset(); + CompleteMemberDetail detail_grandfather = TypeObjectUtils::build_complete_member_detail(name_grandfather, member_ann_builtin_grandfather, ann_custom_GrandfatherStruct); + CompleteStructMember member_grandfather = TypeObjectUtils::build_complete_struct_member(common_grandfather, detail_grandfather); + TypeObjectUtils::add_complete_struct_member(member_seq_GrandfatherStruct, member_grandfather); + } + CompleteStructType struct_type_GrandfatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GrandfatherStruct, header_GrandfatherStruct, member_seq_GrandfatherStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_GrandfatherStruct, type_name_GrandfatherStruct.to_string(), type_ids_GrandfatherStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GrandfatherStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_FatherStruct_type_identifier( + TypeIdentifierPair& type_ids_FatherStruct) +{ + + ReturnCode_t return_code_FatherStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_FatherStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FatherStruct", type_ids_FatherStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_FatherStruct) + { + StructTypeFlag struct_flags_FatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_FatherStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandfatherStruct", type_ids_FatherStruct); + + if (return_code_FatherStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_GrandfatherStruct_type_identifier(type_ids_FatherStruct); + } + QualifiedTypeName type_name_FatherStruct = "FatherStruct"; + eprosima::fastcdr::optional type_ann_builtin_FatherStruct; + eprosima::fastcdr::optional ann_custom_FatherStruct; + CompleteTypeDetail detail_FatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FatherStruct, ann_custom_FatherStruct, type_name_FatherStruct.to_string()); + CompleteStructHeader header_FatherStruct; + if (EK_COMPLETE == type_ids_FatherStruct.type_identifier1()._d()) + { + header_FatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_FatherStruct.type_identifier1(), detail_FatherStruct); + } + else if (EK_COMPLETE == type_ids_FatherStruct.type_identifier2()._d()) + { + header_FatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_FatherStruct.type_identifier2(), detail_FatherStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FatherStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_FatherStruct; + { + TypeIdentifierPair type_ids_father; + ReturnCode_t return_code_father {eprosima::fastdds::dds::RETCODE_OK}; + return_code_father = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_father); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_father) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "father Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_father = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_father = 0x00000002; + bool common_father_ec {false}; + CommonStructMember common_father {TypeObjectUtils::build_common_struct_member(member_id_father, member_flags_father, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_father, common_father_ec))}; + if (!common_father_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure father member TypeIdentifier inconsistent."); + return; + } + MemberName name_father = "father"; + eprosima::fastcdr::optional member_ann_builtin_father; + ann_custom_FatherStruct.reset(); + CompleteMemberDetail detail_father = TypeObjectUtils::build_complete_member_detail(name_father, member_ann_builtin_father, ann_custom_FatherStruct); + CompleteStructMember member_father = TypeObjectUtils::build_complete_struct_member(common_father, detail_father); + TypeObjectUtils::add_complete_struct_member(member_seq_FatherStruct, member_father); + } + CompleteStructType struct_type_FatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FatherStruct, header_FatherStruct, member_seq_FatherStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_FatherStruct, type_name_FatherStruct.to_string(), type_ids_FatherStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "FatherStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_SonStruct_type_identifier( + TypeIdentifierPair& type_ids_SonStruct) +{ + + ReturnCode_t return_code_SonStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_SonStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SonStruct", type_ids_SonStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_SonStruct) + { + StructTypeFlag struct_flags_SonStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_SonStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "FatherStruct", type_ids_SonStruct); + + if (return_code_SonStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_FatherStruct_type_identifier(type_ids_SonStruct); + } + QualifiedTypeName type_name_SonStruct = "SonStruct"; + eprosima::fastcdr::optional type_ann_builtin_SonStruct; + eprosima::fastcdr::optional ann_custom_SonStruct; + CompleteTypeDetail detail_SonStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SonStruct, ann_custom_SonStruct, type_name_SonStruct.to_string()); + CompleteStructHeader header_SonStruct; + if (EK_COMPLETE == type_ids_SonStruct.type_identifier1()._d()) + { + header_SonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_SonStruct.type_identifier1(), detail_SonStruct); + } + else if (EK_COMPLETE == type_ids_SonStruct.type_identifier2()._d()) + { + header_SonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_SonStruct.type_identifier2(), detail_SonStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "SonStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_SonStruct; + { + TypeIdentifierPair type_ids_son; + ReturnCode_t return_code_son {eprosima::fastdds::dds::RETCODE_OK}; + return_code_son = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_son); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_son) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "son Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_son = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_son = 0x00000003; + bool common_son_ec {false}; + CommonStructMember common_son {TypeObjectUtils::build_common_struct_member(member_id_son, member_flags_son, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_son, common_son_ec))}; + if (!common_son_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure son member TypeIdentifier inconsistent."); + return; + } + MemberName name_son = "son"; + eprosima::fastcdr::optional member_ann_builtin_son; + ann_custom_SonStruct.reset(); + CompleteMemberDetail detail_son = TypeObjectUtils::build_complete_member_detail(name_son, member_ann_builtin_son, ann_custom_SonStruct); + CompleteStructMember member_son = TypeObjectUtils::build_complete_struct_member(common_son, detail_son); + TypeObjectUtils::add_complete_struct_member(member_seq_SonStruct, member_son); + } + CompleteStructType struct_type_SonStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_SonStruct, header_SonStruct, member_seq_SonStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_SonStruct, type_name_SonStruct.to_string(), type_ids_SonStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "SonStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_GrandsonStruct_type_identifier( + TypeIdentifierPair& type_ids_GrandsonStruct) +{ + + ReturnCode_t return_code_GrandsonStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_GrandsonStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandsonStruct", type_ids_GrandsonStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrandsonStruct) + { + StructTypeFlag struct_flags_GrandsonStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_GrandsonStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SonStruct", type_ids_GrandsonStruct); + + if (return_code_GrandsonStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_SonStruct_type_identifier(type_ids_GrandsonStruct); + } + QualifiedTypeName type_name_GrandsonStruct = "GrandsonStruct"; + eprosima::fastcdr::optional type_ann_builtin_GrandsonStruct; + eprosima::fastcdr::optional ann_custom_GrandsonStruct; + CompleteTypeDetail detail_GrandsonStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GrandsonStruct, ann_custom_GrandsonStruct, type_name_GrandsonStruct.to_string()); + CompleteStructHeader header_GrandsonStruct; + if (EK_COMPLETE == type_ids_GrandsonStruct.type_identifier1()._d()) + { + header_GrandsonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandsonStruct.type_identifier1(), detail_GrandsonStruct); + } + else if (EK_COMPLETE == type_ids_GrandsonStruct.type_identifier2()._d()) + { + header_GrandsonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandsonStruct.type_identifier2(), detail_GrandsonStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GrandsonStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_GrandsonStruct; + { + TypeIdentifierPair type_ids_grandson; + ReturnCode_t return_code_grandson {eprosima::fastdds::dds::RETCODE_OK}; + return_code_grandson = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_grandson); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_grandson) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "grandson Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_grandson = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_grandson = 0x00000004; + bool common_grandson_ec {false}; + CommonStructMember common_grandson {TypeObjectUtils::build_common_struct_member(member_id_grandson, member_flags_grandson, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_grandson, common_grandson_ec))}; + if (!common_grandson_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure grandson member TypeIdentifier inconsistent."); + return; + } + MemberName name_grandson = "grandson"; + eprosima::fastcdr::optional member_ann_builtin_grandson; + ann_custom_GrandsonStruct.reset(); + CompleteMemberDetail detail_grandson = TypeObjectUtils::build_complete_member_detail(name_grandson, member_ann_builtin_grandson, ann_custom_GrandsonStruct); + CompleteStructMember member_grandson = TypeObjectUtils::build_complete_struct_member(common_grandson, detail_grandson); + TypeObjectUtils::add_complete_struct_member(member_seq_GrandsonStruct, member_grandson); + } + CompleteStructType struct_type_GrandsonStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GrandsonStruct, header_GrandsonStruct, member_seq_GrandsonStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_GrandsonStruct, type_name_GrandsonStruct.to_string(), type_ids_GrandsonStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GrandsonStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_inheritance_struct_type_identifier( + TypeIdentifierPair& type_ids_inheritance_struct) +{ + + ReturnCode_t return_code_inheritance_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_inheritance_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "inheritance_struct", type_ids_inheritance_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_inheritance_struct) + { + StructTypeFlag struct_flags_inheritance_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_inheritance_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandsonStruct", type_ids_inheritance_struct); + + if (return_code_inheritance_struct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_GrandsonStruct_type_identifier(type_ids_inheritance_struct); + } + QualifiedTypeName type_name_inheritance_struct = "inheritance_struct"; + eprosima::fastcdr::optional type_ann_builtin_inheritance_struct; + eprosima::fastcdr::optional ann_custom_inheritance_struct; + CompleteTypeDetail detail_inheritance_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_inheritance_struct, ann_custom_inheritance_struct, type_name_inheritance_struct.to_string()); + CompleteStructHeader header_inheritance_struct; + if (EK_COMPLETE == type_ids_inheritance_struct.type_identifier1()._d()) + { + header_inheritance_struct = TypeObjectUtils::build_complete_struct_header(type_ids_inheritance_struct.type_identifier1(), detail_inheritance_struct); + } + else if (EK_COMPLETE == type_ids_inheritance_struct.type_identifier2()._d()) + { + header_inheritance_struct = TypeObjectUtils::build_complete_struct_header(type_ids_inheritance_struct.type_identifier2(), detail_inheritance_struct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "inheritance_struct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_inheritance_struct; + { + TypeIdentifierPair type_ids_value; + ReturnCode_t return_code_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_value = 0x00000005; + bool common_value_ec {false}; + CommonStructMember common_value {TypeObjectUtils::build_common_struct_member(member_id_value, member_flags_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_value, common_value_ec))}; + if (!common_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure value member TypeIdentifier inconsistent."); + return; + } + MemberName name_value = "value"; + eprosima::fastcdr::optional member_ann_builtin_value; + ann_custom_inheritance_struct.reset(); + CompleteMemberDetail detail_value = TypeObjectUtils::build_complete_member_detail(name_value, member_ann_builtin_value, ann_custom_inheritance_struct); + CompleteStructMember member_value = TypeObjectUtils::build_complete_struct_member(common_value, detail_value); + TypeObjectUtils::add_complete_struct_member(member_seq_inheritance_struct, member_value); + } + CompleteStructType struct_type_inheritance_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_inheritance_struct, header_inheritance_struct, member_seq_inheritance_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_inheritance_struct, type_name_inheritance_struct.to_string(), type_ids_inheritance_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "inheritance_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..cece8aff483 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp @@ -0,0 +1,116 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file inheritance_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register GreatgrandfatherStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_GreatgrandfatherStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register GrandfatherStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_GrandfatherStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register FatherStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_FatherStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register SonStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_SonStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register GrandsonStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_GrandsonStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register inheritance_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_inheritance_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ From 54308b6bd1e863fa6858b1b6eb1477e1b304bc33 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 4 Jul 2024 12:30:23 +0200 Subject: [PATCH 35/52] Rebase fix Signed-off-by: tempate --- src/cpp/fastdds/xtypes/utils.cpp | 645 ------------------ .../type_conversion/types/all_types.hpp | 36 +- .../alias_struct/alias_struct.hpp | 4 +- .../alias_struct/alias_structCdrAux.hpp | 6 +- .../alias_struct/alias_structCdrAux.ipp | 6 +- .../alias_struct/alias_structPubSubTypes.cxx | 14 +- ...SubTypes.h => alias_structPubSubTypes.hpp} | 28 +- .../alias_structTypeObjectSupport.hpp | 6 +- .../arrays_and_sequences.hpp | 4 +- .../arrays_and_sequencesCdrAux.hpp | 6 +- .../arrays_and_sequencesCdrAux.ipp | 6 +- .../arrays_and_sequencesPubSubTypes.cxx | 26 +- ....h => arrays_and_sequencesPubSubTypes.hpp} | 42 +- .../arrays_and_sequencesTypeObjectSupport.hpp | 6 +- .../basic_array_struct/basic_array_struct.hpp | 4 +- .../basic_array_structCdrAux.hpp | 6 +- .../basic_array_structCdrAux.ipp | 6 +- .../basic_array_structPubSubTypes.cxx | 26 +- ...es.h => basic_array_structPubSubTypes.hpp} | 42 +- .../basic_array_structTypeObjectSupport.hpp | 6 +- .../basic_struct/basic_struct.hpp | 4 +- .../basic_struct/basic_structCdrAux.hpp | 6 +- .../basic_struct/basic_structCdrAux.ipp | 6 +- .../basic_struct/basic_structPubSubTypes.cxx | 26 +- ...SubTypes.h => basic_structPubSubTypes.hpp} | 42 +- .../basic_structTypeObjectSupport.hpp | 6 +- .../bitmask_struct/bitmask_struct.hpp | 4 +- .../bitmask_struct/bitmask_structCdrAux.hpp | 6 +- .../bitmask_struct/bitmask_structCdrAux.ipp | 6 +- .../bitmask_structPubSubTypes.cxx | 14 +- ...bTypes.h => bitmask_structPubSubTypes.hpp} | 28 +- .../bitmask_structTypeObjectSupport.hpp | 6 +- .../bitset_struct/bitset_struct.hpp | 4 +- .../bitset_struct/bitset_structCdrAux.hpp | 6 +- .../bitset_struct/bitset_structCdrAux.ipp | 6 +- .../bitset_structPubSubTypes.cxx | 14 +- ...ubTypes.h => bitset_structPubSubTypes.hpp} | 28 +- .../bitset_structTypeObjectSupport.cxx | 2 +- .../bitset_structTypeObjectSupport.hpp | 6 +- .../char_sequence/char_sequence.hpp | 4 +- .../char_sequence/char_sequenceCdrAux.hpp | 6 +- .../char_sequence/char_sequenceCdrAux.ipp | 6 +- .../char_sequencePubSubTypes.cxx | 14 +- ...ubTypes.h => char_sequencePubSubTypes.hpp} | 28 +- .../char_sequenceTypeObjectSupport.hpp | 6 +- .../complex_nested_arrays.hpp | 4 +- .../complex_nested_arraysCdrAux.hpp | 6 +- .../complex_nested_arraysCdrAux.ipp | 6 +- .../complex_nested_arraysPubSubTypes.cxx | 50 +- ...h => complex_nested_arraysPubSubTypes.hpp} | 70 +- ...complex_nested_arraysTypeObjectSupport.hpp | 6 +- .../type_objects/enum_struct/enum_struct.hpp | 6 +- .../enum_struct/enum_structCdrAux.hpp | 6 +- .../enum_struct/enum_structCdrAux.ipp | 6 +- .../enum_struct/enum_structPubSubTypes.cxx | 14 +- ...bSubTypes.h => enum_structPubSubTypes.hpp} | 28 +- .../enum_structTypeObjectSupport.hpp | 6 +- .../extensibility_struct.hpp | 4 +- .../extensibility_structCdrAux.hpp | 6 +- .../extensibility_structCdrAux.ipp | 6 +- .../extensibility_structPubSubTypes.cxx | 50 +- ....h => extensibility_structPubSubTypes.hpp} | 72 +- .../extensibility_structTypeObjectSupport.hpp | 6 +- .../float_bounded_sequence.hpp | 4 +- .../float_bounded_sequenceCdrAux.hpp | 6 +- .../float_bounded_sequenceCdrAux.ipp | 6 +- .../float_bounded_sequencePubSubTypes.cxx | 14 +- ... => float_bounded_sequencePubSubTypes.hpp} | 28 +- ...loat_bounded_sequenceTypeObjectSupport.hpp | 6 +- .../type_objects/hello_world/hello_world.hpp | 4 +- .../hello_world/hello_worldCdrAux.hpp | 6 +- .../hello_world/hello_worldCdrAux.ipp | 6 +- .../hello_world/hello_worldPubSubTypes.cxx | 14 +- ...bSubTypes.h => hello_worldPubSubTypes.hpp} | 28 +- .../hello_worldTypeObjectSupport.hpp | 6 +- .../inheritance_struct/inheritance_struct.hpp | 4 +- .../inheritance_structCdrAux.hpp | 6 +- .../inheritance_structCdrAux.ipp | 6 +- .../inheritance_structPubSubTypes.cxx | 74 +- ...es.h => inheritance_structPubSubTypes.hpp} | 98 +-- .../inheritance_structTypeObjectSupport.hpp | 6 +- .../type_objects/key_struct/key_struct.hpp | 4 +- .../key_struct/key_structCdrAux.hpp | 6 +- .../key_struct/key_structCdrAux.ipp | 6 +- .../key_struct/key_structPubSubTypes.cxx | 14 +- ...ubSubTypes.h => key_structPubSubTypes.hpp} | 28 +- .../key_structTypeObjectSupport.hpp | 6 +- .../type_objects/map_struct/map_struct.hpp | 4 +- .../map_struct/map_structCdrAux.hpp | 6 +- .../map_struct/map_structCdrAux.ipp | 6 +- .../map_struct/map_structPubSubTypes.cxx | 14 +- ...ubSubTypes.h => map_structPubSubTypes.hpp} | 28 +- .../map_structTypeObjectSupport.hpp | 6 +- .../nested_struct/nested_struct.hpp | 4 +- .../nested_struct/nested_structCdrAux.hpp | 6 +- .../nested_struct/nested_structCdrAux.ipp | 6 +- .../nested_structPubSubTypes.cxx | 74 +- ...ubTypes.h => nested_structPubSubTypes.hpp} | 98 +-- .../nested_structTypeObjectSupport.hpp | 6 +- .../numeric_array/numeric_array.hpp | 4 +- .../numeric_array/numeric_arrayCdrAux.hpp | 6 +- .../numeric_array/numeric_arrayCdrAux.ipp | 6 +- .../numeric_arrayPubSubTypes.cxx | 14 +- ...ubTypes.h => numeric_arrayPubSubTypes.hpp} | 28 +- .../numeric_arrayTypeObjectSupport.hpp | 6 +- .../types/type_objects/regenerate_types.bash | 21 + .../union_struct/union_struct.hpp | 4 +- .../union_struct/union_structCdrAux.hpp | 6 +- .../union_struct/union_structCdrAux.ipp | 6 +- .../union_struct/union_structPubSubTypes.cxx | 14 +- ...SubTypes.h => union_structPubSubTypes.hpp} | 28 +- .../union_structTypeObjectSupport.hpp | 6 +- 112 files changed, 865 insertions(+), 1489 deletions(-) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/{alias_structPubSubTypes.h => alias_structPubSubTypes.hpp} (85%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/{arrays_and_sequencesPubSubTypes.h => arrays_and_sequencesPubSubTypes.hpp} (86%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/{basic_array_structPubSubTypes.h => basic_array_structPubSubTypes.hpp} (86%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/{basic_structPubSubTypes.h => basic_structPubSubTypes.hpp} (86%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/{bitmask_structPubSubTypes.h => bitmask_structPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/{bitset_structPubSubTypes.h => bitset_structPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/{char_sequencePubSubTypes.h => char_sequencePubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/{complex_nested_arraysPubSubTypes.h => complex_nested_arraysPubSubTypes.hpp} (87%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/{enum_structPubSubTypes.h => enum_structPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/{extensibility_structPubSubTypes.h => extensibility_structPubSubTypes.hpp} (87%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/{float_bounded_sequencePubSubTypes.h => float_bounded_sequencePubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/{hello_worldPubSubTypes.h => hello_worldPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/{inheritance_structPubSubTypes.h => inheritance_structPubSubTypes.hpp} (88%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/{key_structPubSubTypes.h => key_structPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/{map_structPubSubTypes.h => map_structPubSubTypes.hpp} (84%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/{nested_structPubSubTypes.h => nested_structPubSubTypes.hpp} (88%) rename test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/{numeric_arrayPubSubTypes.h => numeric_arrayPubSubTypes.hpp} (84%) create mode 100644 test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash rename test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/{union_structPubSubTypes.h => union_structPubSubTypes.hpp} (84%) diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index ad1128a4354..0112a68cd0d 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -67,651 +67,6 @@ ReturnCode_t json_serialize( return ret; } -} // namespace dds -} // namespace fastdds - -/////////////////////////////////////// -// Dynamic Type to IDL serialization // -/////////////////////////////////////// - -//// Forward declarations and constants - -constexpr const char* TYPE_OPENING = - "\n{\n"; - -constexpr const char* TYPE_CLOSURE = - "};\n"; - -constexpr const char* TAB_SEPARATOR = - " "; - -struct TreeNodeType -{ - TreeNodeType( - std::string member_name, - std::string type_kind_name, - DynamicType::_ref_type dynamic_type) - : member_name(member_name) - , type_kind_name(type_kind_name) - , dynamic_type(dynamic_type) - { - } - - std::string member_name; - std::string type_kind_name; - DynamicType::_ref_type dynamic_type; -}; - -ReturnCode_t type_kind_to_str( - const DynamicType::_ref_type& type, - std::string& type_str) noexcept; - -//// Implementation - -ReturnCode_t container_internal_type( - const DynamicType::_ref_type& dyn_type, - DynamicType::_ref_type& internal_type) noexcept -{ - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = dyn_type->get_descriptor(type_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - internal_type = type_descriptor->element_type(); - - return RETCODE_OK; -} - -ReturnCode_t container_size( - const DynamicType::_ref_type& dyn_type, - BoundSeq& bounds) noexcept -{ - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - const auto ret = dyn_type->get_descriptor(type_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - bounds = type_descriptor->bound(); - - return RETCODE_OK; -} - -ReturnCode_t get_members_sorted( - const DynamicType::_ref_type& dyn_type, - std::vector>& result) noexcept -{ - std::map members; - dyn_type->get_all_members(members); - - for (const auto& member : members) - { - MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - const auto ret = member.second->get_descriptor(member_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - const auto dyn_name = member.second->get_name(); - result.emplace_back( - std::make_pair( - dyn_name.to_string(), - std::move(member_descriptor->type()))); - } - - return RETCODE_OK; -} - -ReturnCode_t array_kind_to_str( - const DynamicType::_ref_type& dyn_type, - std::string& array_str) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - DynamicType::_ref_type internal_type; - ret = container_internal_type(dyn_type, internal_type); - - if (ret != RETCODE_OK) - { - return ret; - } - - ret = type_kind_to_str(internal_type, array_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - BoundSeq bounds; - ret = container_size(dyn_type, bounds); - - if (ret != RETCODE_OK) - { - return ret; - } - - for (const auto& bound : bounds) - { - array_str += "["; - array_str += bound; - array_str += "]"; - } - - return ret; -} - -ReturnCode_t sequence_kind_to_str( - const DynamicType::_ref_type& dyn_type, - std::string& sequence_str) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - DynamicType::_ref_type internal_type; - ret = container_internal_type(dyn_type, internal_type); - - if (ret != RETCODE_OK) - { - return ret; - } - - ret = type_kind_to_str(internal_type, sequence_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - sequence_str = "sequence<" + sequence_str; - - BoundSeq bounds; - ret = container_size(dyn_type, bounds); - - if (ret != RETCODE_OK) - { - return ret; - } - - for (const auto& bound : bounds) - { - sequence_str += ", " + bound; - } - - sequence_str += ">"; - - return ret; -} - -ReturnCode_t map_kind_to_str( - const DynamicType::_ref_type& dyn_type, - std::string& map_str) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = dyn_type->get_descriptor(type_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - std::string key_str; - const auto key_type = type_descriptor->key_element_type(); - ret = type_kind_to_str(key_type, key_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - std::string value_str; - const auto value_type = type_descriptor->element_type(); - ret = type_kind_to_str(value_type, value_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - std::stringstream ss; - - ss << "map<" << key_str << ", " << value_str << ">"; - - map_str = ss.str(); - - return ret; -} - -ReturnCode_t type_kind_to_str( - const DynamicType::_ref_type& dyn_type, - std::string& type_str) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - switch (dyn_type->get_kind()) - { - case TK_BOOLEAN: - { - type_str = "boolean"; - break; - } - case TK_BYTE: - { - type_str = "octet"; - break; - } - case TK_INT16: - { - type_str = "short"; - break; - } - case TK_INT32: - { - type_str = "long"; - break; - } - case TK_INT64: - { - type_str = "long long"; - break; - } - case TK_UINT16: - { - type_str = "unsigned short"; - break; - } - case TK_UINT32: - { - type_str = "unsigned long"; - break; - } - case TK_UINT64: - { - type_str = "unsigned long long"; - break; - } - case TK_FLOAT32: - { - type_str = "float"; - break; - } - case TK_FLOAT64: - { - type_str = "double"; - break; - } - case TK_FLOAT128: - { - type_str = "long double"; - break; - } - case TK_CHAR8: - { - type_str = "char"; - break; - } - case TK_CHAR16: - { - type_str = "wchar"; - break; - } - case TK_STRING8: - { - type_str = "string"; - break; - } - case TK_STRING16: - { - type_str = "wstring"; - break; - } - case TK_ARRAY: - { - ret = array_kind_to_str(dyn_type, type_str); - break; - } - case TK_SEQUENCE: - { - ret = sequence_kind_to_str(dyn_type, type_str); - break; - } - case TK_MAP: - { - ret = map_kind_to_str(dyn_type, type_str); - break; - } - case TK_STRUCTURE: - case TK_ENUM: - case TK_UNION: - { - type_str = dyn_type->get_name().to_string(); - break; - } - case TK_BITSET: - case TK_BITMASK: - case TK_NONE: - case TK_ALIAS: - { - ret = RETCODE_UNSUPPORTED; - break; - } - default: - { - ret = RETCODE_BAD_PARAMETER; - break; - } - } - - return ret; -} - -ReturnCode_t generate_dyn_type_tree( - const DynamicType::_ref_type& type, - const std::string& member_name, - utilities::collections::TreeNode& node) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - switch (type->get_kind()) - { - case TK_STRUCTURE: - { - // If is struct, the call is recursive. - // Create new tree node - utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); - - // Get all members of this struct - std::vector> members_by_name; - ret = get_members_sorted(type, members_by_name); - - if (ret != RETCODE_OK) - { - return ret; - } - - for (const auto& member : members_by_name) - { - ret = generate_dyn_type_tree(member.second, member.first, node); - - if (ret != RETCODE_OK) - { - return ret; - } - - // Add each member with its name as a new node in a branch (recursion) - parent.add_branch(node); - } - - node = parent; - break; - } - case TK_ARRAY: - case TK_SEQUENCE: - { - // If container (array or struct) has exactly one branch - // Calculate child branch - DynamicType::_ref_type internal_type; - ret = container_internal_type(type, internal_type); - - if (ret != RETCODE_OK) - { - return ret; - } - - std::string internal_str; - ret = type_kind_to_str(internal_type, internal_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - // Create this node - utilities::collections::TreeNode container(member_name, internal_str, type); - // Add branch - ret = generate_dyn_type_tree(internal_type, "CONTAINER_MEMBER", node); - - if (ret != RETCODE_OK) - { - return ret; - } - - container.add_branch(node); - - node = container; - break; - } - default: - { - std::string type_str; - ret = type_kind_to_str(type, type_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - node = utilities::collections::TreeNode(member_name, type_str, type); - break; - } - } - - return ret; -} - -ReturnCode_t node_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept -{ - os << TAB_SEPARATOR; - - if (node.info.dynamic_type->get_kind() == TK_ARRAY) - { - auto dim_pos = node.info.type_kind_name.find("["); - auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); - auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); - - os << kind_name_str << " " << node.info.member_name << dim_str; - } - else - { - os << node.info.type_kind_name << " " << node.info.member_name; - } - - return RETCODE_OK; -} - -ReturnCode_t struct_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept -{ - // Add types name - os << "struct " << node.info.type_kind_name << TYPE_OPENING; - - // Add struct attributes - for (auto const& child : node.branches()) - { - node_to_str(os, child.info); - os << ";\n"; - } - - // Close definition - os << TYPE_CLOSURE; - - return RETCODE_OK; -} - -ReturnCode_t enum_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept -{ - os << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; - - std::map members; - node.info.dynamic_type->get_all_members(members); - bool first_iter = true; - for (const auto& member : members) - { - if (!first_iter) - { - os << ",\n" << TAB_SEPARATOR; - } - first_iter = false; - - os << member.second->get_name(); - } - - // Close definition - os << "\n" << TYPE_CLOSURE; - - return RETCODE_OK; -} - -ReturnCode_t union_to_str( - std::ostream& os, - const utilities::collections::TreeNode& node) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = node.info.dynamic_type->get_descriptor(type_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - std::string discriminant_type_str; - ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - os << "union " << node.info.type_kind_name << " switch (" << discriminant_type_str << ")" << TYPE_OPENING; - - std::map members; - node.info.dynamic_type->get_all_members(members); // WARNING: Default case not included in this collection, and currently not available - - for (const auto& member : members) - { - MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member.second->get_descriptor(member_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration - bool first_iter = true; - - for (const auto& label : labels) - { - if (first_iter) - { - os << TAB_SEPARATOR; - } - else - { - os << " "; - } - first_iter = false; - - os << "case " << std::to_string(label) << ":"; - } - - std::string member_str; - ret = type_kind_to_str(member_descriptor->type(), member_str); - - if (ret != RETCODE_OK) - { - return ret; - } - - os << "\n" << TAB_SEPARATOR << TAB_SEPARATOR << member_str << " " << member.second->get_name() << ";\n"; - } - - // Close definition - os << TYPE_CLOSURE; - - return ret; -} - -ReturnCode_t generate_dyn_type_schema_from_tree( - const utilities::collections::TreeNode& parent_node, - std::string& dyn_type_schema) noexcept -{ - std::set types_written; - - std::stringstream ss; - - // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). - // If it is, check if it is not yet written - // If it is not, write it down - for (const auto& node : parent_node.all_nodes()) - { - if (types_written.find(node.info.type_kind_name) != types_written.end()) - { - continue; - } - - ReturnCode_t ret; - const auto kind = node.info.dynamic_type->get_kind(); - - switch (kind) - { - case TK_STRUCTURE: - { - ret = struct_to_str(ss, node); - break; - } - case TK_ENUM: - { - ret = enum_to_str(ss, node); - break; - } - case TK_UNION: - { - ret = union_to_str(ss, node); - break; - } - default: - continue; - } - - if (ret != RETCODE_OK) - { - return ret; - } - - ss << "\n"; // Introduce blank line between type definitions - types_written.insert(node.info.type_kind_name); - } - - // Write struct parent node at last, after all its dependencies - // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent - const auto ret = struct_to_str(ss, parent_node); - - if (ret != RETCODE_OK) - { - return ret; - } - - dyn_type_schema = ss.str(); - - return RETCODE_OK; -} - ReturnCode_t idl_serialize( const traits::ref_type& dynamic_type, std::string& output) noexcept diff --git a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp index dc9864957bd..eae5506107c 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/all_types.hpp @@ -21,58 +21,58 @@ #include #include "type_objects/alias_struct/alias_struct.hpp" -#include "type_objects/alias_struct/alias_structPubSubTypes.h" +#include "type_objects/alias_struct/alias_structPubSubTypes.hpp" #include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" -#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h" +#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp" #include "type_objects/basic_array_struct/basic_array_struct.hpp" -#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.h" +#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp" #include "type_objects/basic_struct/basic_struct.hpp" -#include "type_objects/basic_struct/basic_structPubSubTypes.h" +#include "type_objects/basic_struct/basic_structPubSubTypes.hpp" #include "type_objects/bitmask_struct/bitmask_struct.hpp" -#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.h" +#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp" #include "type_objects/bitset_struct/bitset_struct.hpp" -#include "type_objects/bitset_struct/bitset_structPubSubTypes.h" +#include "type_objects/bitset_struct/bitset_structPubSubTypes.hpp" #include "type_objects/char_sequence/char_sequence.hpp" -#include "type_objects/char_sequence/char_sequencePubSubTypes.h" +#include "type_objects/char_sequence/char_sequencePubSubTypes.hpp" #include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" -#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h" +#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp" #include "type_objects/enum_struct/enum_struct.hpp" -#include "type_objects/enum_struct/enum_structPubSubTypes.h" +#include "type_objects/enum_struct/enum_structPubSubTypes.hpp" #include "type_objects/extensibility_struct/extensibility_struct.hpp" -#include "type_objects/extensibility_struct/extensibility_structPubSubTypes.h" +#include "type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp" #include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" -#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h" +#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp" #include "type_objects/hello_world/hello_world.hpp" -#include "type_objects/hello_world/hello_worldPubSubTypes.h" +#include "type_objects/hello_world/hello_worldPubSubTypes.hpp" #include "type_objects/inheritance_struct/inheritance_struct.hpp" -#include "type_objects/inheritance_struct/inheritance_structPubSubTypes.h" +#include "type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp" #include "type_objects/key_struct/key_struct.hpp" -#include "type_objects/key_struct/key_structPubSubTypes.h" +#include "type_objects/key_struct/key_structPubSubTypes.hpp" #include "type_objects/map_struct/map_struct.hpp" -#include "type_objects/map_struct/map_structPubSubTypes.h" +#include "type_objects/map_struct/map_structPubSubTypes.hpp" #include "type_objects/nested_struct/nested_struct.hpp" -#include "type_objects/nested_struct/nested_structPubSubTypes.h" +#include "type_objects/nested_struct/nested_structPubSubTypes.hpp" #include "type_objects/numeric_array/numeric_array.hpp" -#include "type_objects/numeric_array/numeric_arrayPubSubTypes.h" +#include "type_objects/numeric_array/numeric_arrayPubSubTypes.hpp" #include "type_objects/union_struct/union_struct.hpp" -#include "type_objects/union_struct/union_structPubSubTypes.h" +#include "type_objects/union_struct/union_structPubSubTypes.hpp" namespace test { diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp index 0be2ee5c1df..7afdd76c685 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_ALIAS_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__ALIAS_STRUCT_HPP +#define FAST_DDS_GENERATED__ALIAS_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp index 5fc277cb939..46cc826df1f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_HPP #include "alias_struct.hpp" @@ -45,5 +45,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp index 10094e3f928..5094322b724 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_IPP #include "alias_structCdrAux.hpp" @@ -130,5 +130,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ALIAS_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__ALIAS_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx index 7eba7f2c21a..04e1a8c24b8 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "alias_structPubSubTypes.h" +#include "alias_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ alias_structPubSubType::~alias_structPubSubType() } bool alias_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - alias_struct* p_type = static_cast(data); + const alias_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool alias_structPubSubType::deserialize( } std::function alias_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function alias_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void alias_structPubSubType::deleteData( } bool alias_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool alias_structPubSubType::getKey( return false; } - alias_struct* p_type = static_cast(data); + const alias_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.hpp similarity index 85% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.hpp index 647b2d3947a..86e0e6fadfd 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file alias_structPubSubTypes.h + * @file alias_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__ALIAS_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__ALIAS_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "alias_struct.hpp" @@ -56,14 +56,14 @@ class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~alias_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -72,17 +72,17 @@ class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -109,7 +109,7 @@ class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -127,10 +127,10 @@ class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_ALIAS_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__ALIAS_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp index 055027fe0a4..acb6fd3d1a5 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -95,4 +95,4 @@ eProsima_user_DllExport void register_alias_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__ALIAS_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp index eff9b5ef6e7..e94655a430f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ -#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ +#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_HPP +#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp index a8be1936252..d777ee1c1c2 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP +#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP #include "arrays_and_sequences.hpp" @@ -49,5 +49,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp index d5d27a39065..8a5c223f8c1 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP +#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP #include "arrays_and_sequencesCdrAux.hpp" @@ -214,5 +214,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCESCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx index 43aa37c67a8..cd805263983 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "arrays_and_sequencesPubSubTypes.h" +#include "arrays_and_sequencesPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ AnInternalObjectPubSubType::~AnInternalObjectPubSubType() } bool AnInternalObjectPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - AnInternalObject* p_type = static_cast(data); + const AnInternalObject* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool AnInternalObjectPubSubType::deserialize( } std::function AnInternalObjectPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function AnInternalObjectPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void AnInternalObjectPubSubType::deleteData( } bool AnInternalObjectPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool AnInternalObjectPubSubType::getKey( return false; } - AnInternalObject* p_type = static_cast(data); + const AnInternalObject* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ arrays_and_sequencesPubSubType::~arrays_and_sequencesPubSubType() } bool arrays_and_sequencesPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - arrays_and_sequences* p_type = static_cast(data); + const arrays_and_sequences* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool arrays_and_sequencesPubSubType::deserialize( } std::function arrays_and_sequencesPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function arrays_and_sequencesPubSubType::getSerializedSizeProvi eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void arrays_and_sequencesPubSubType::deleteData( } bool arrays_and_sequencesPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool arrays_and_sequencesPubSubType::getKey( return false; } - arrays_and_sequences* p_type = static_cast(data); + const arrays_and_sequences* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp similarity index 86% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp index e3642121d59..4b3677a405a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file arrays_and_sequencesPubSubTypes.h + * @file arrays_and_sequencesPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "arrays_and_sequences.hpp" @@ -53,14 +53,14 @@ class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~AnInternalObjectPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataT eProsima_user_DllExport ~arrays_and_sequencesPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataT void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataT } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,10 +215,10 @@ class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataT #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp index 6f6fb0541fd..43f145f3861 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_arrays_and_sequences_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp index bd064fe71c1..1352a2e4120 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_HPP +#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp index aa07447f34f..3bbf1a9a2a7 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP #include "basic_array_struct.hpp" @@ -49,5 +49,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp index 4d1ab4f1910..ebd5483e40b 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP #include "basic_array_structCdrAux.hpp" @@ -206,5 +206,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx index b5359c6be69..88043626bce 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "basic_array_structPubSubTypes.h" +#include "basic_array_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ TheOtherObjectInArrayPubSubType::~TheOtherObjectInArrayPubSubType() } bool TheOtherObjectInArrayPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - TheOtherObjectInArray* p_type = static_cast(data); + const TheOtherObjectInArray* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool TheOtherObjectInArrayPubSubType::deserialize( } std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProv eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void TheOtherObjectInArrayPubSubType::deleteData( } bool TheOtherObjectInArrayPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool TheOtherObjectInArrayPubSubType::getKey( return false; } - TheOtherObjectInArray* p_type = static_cast(data); + const TheOtherObjectInArray* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ basic_array_structPubSubType::~basic_array_structPubSubType() } bool basic_array_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - basic_array_struct* p_type = static_cast(data); + const basic_array_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool basic_array_structPubSubType::deserialize( } std::function basic_array_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function basic_array_structPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void basic_array_structPubSubType::deleteData( } bool basic_array_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool basic_array_structPubSubType::getKey( return false; } - basic_array_struct* p_type = static_cast(data); + const basic_array_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp similarity index 86% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp index 4160c1bb961..057e6dda7c6 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file basic_array_structPubSubTypes.h + * @file basic_array_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "basic_array_struct.hpp" @@ -53,14 +53,14 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData eProsima_user_DllExport ~TheOtherObjectInArrayPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp eProsima_user_DllExport ~basic_array_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,10 +215,10 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp index c6be16a7745..afa3f5f98b0 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_basic_array_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp index 03642cf33f2..9ba4805a4d8 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_HPP +#define FAST_DDS_GENERATED__BASIC_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp index 1b9a2ea8765..ac32e369114 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP #include "basic_struct.hpp" @@ -49,5 +49,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp index d936fdf2123..baa8d4ad23d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP #include "basic_structCdrAux.hpp" @@ -190,5 +190,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BASIC_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx index 32bca4addb2..e42464daefa 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "basic_structPubSubTypes.h" +#include "basic_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ TheOtherObjectPubSubType::~TheOtherObjectPubSubType() } bool TheOtherObjectPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - TheOtherObject* p_type = static_cast(data); + const TheOtherObject* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool TheOtherObjectPubSubType::deserialize( } std::function TheOtherObjectPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function TheOtherObjectPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void TheOtherObjectPubSubType::deleteData( } bool TheOtherObjectPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool TheOtherObjectPubSubType::getKey( return false; } - TheOtherObject* p_type = static_cast(data); + const TheOtherObject* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ basic_structPubSubType::~basic_structPubSubType() } bool basic_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - basic_struct* p_type = static_cast(data); + const basic_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool basic_structPubSubType::deserialize( } std::function basic_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function basic_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void basic_structPubSubType::deleteData( } bool basic_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool basic_structPubSubType::getKey( return false; } - basic_struct* p_type = static_cast(data); + const basic_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.hpp similarity index 86% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.hpp index b51cf7149f2..29824879bb8 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file basic_structPubSubTypes.h + * @file basic_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "basic_struct.hpp" @@ -53,14 +53,14 @@ class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~TheOtherObjectPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~basic_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,10 +215,10 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp index 63cc1a64d7c..d2cc9a7407e 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_basic_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp index 24d770fb959..cd015d0d19d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_BITMASK_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__BITMASK_STRUCT_HPP +#define FAST_DDS_GENERATED__BITMASK_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp index 18dcad3ce11..78cf5b1751f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_HPP #include "bitmask_struct.hpp" @@ -43,5 +43,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp index 4d520739874..125ea1044a8 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_IPP #include "bitmask_structCdrAux.hpp" @@ -114,5 +114,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BITMASK_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__BITMASK_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx index 2bc4cc6fe0b..c0f391078b6 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "bitmask_structPubSubTypes.h" +#include "bitmask_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ bitmask_structPubSubType::~bitmask_structPubSubType() } bool bitmask_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - bitmask_struct* p_type = static_cast(data); + const bitmask_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool bitmask_structPubSubType::deserialize( } std::function bitmask_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function bitmask_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void bitmask_structPubSubType::deleteData( } bool bitmask_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool bitmask_structPubSubType::getKey( return false; } - bitmask_struct* p_type = static_cast(data); + const bitmask_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp index 1bc99c35a6c..1687d0a15ea 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file bitmask_structPubSubTypes.h + * @file bitmask_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__BITMASK_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__BITMASK_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "bitmask_struct.hpp" @@ -53,14 +53,14 @@ class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~bitmask_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_BITMASK_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__BITMASK_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp index c0caa908537..6ca789acd69 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_bitmask_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__BITMASK_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp index 316e02f2e12..dc8880f0db0 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_BITSET_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__BITSET_STRUCT_HPP +#define FAST_DDS_GENERATED__BITSET_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp index f1bc5d159d4..41c9571f738 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_HPP #include "bitset_struct.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp index 0901d76b93e..5c1126e6620 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_IPP #include "bitset_structCdrAux.hpp" @@ -172,5 +172,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_BITSET_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__BITSET_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx index ff45facbc19..6fb212595e7 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "bitset_structPubSubTypes.h" +#include "bitset_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ bitset_structPubSubType::~bitset_structPubSubType() } bool bitset_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - bitset_struct* p_type = static_cast(data); + const bitset_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool bitset_structPubSubType::deserialize( } std::function bitset_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function bitset_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void bitset_structPubSubType::deleteData( } bool bitset_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool bitset_structPubSubType::getKey( return false; } - bitset_struct* p_type = static_cast(data); + const bitset_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.hpp index cbfaa2bd9b4..7246cb4721a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file bitset_structPubSubTypes.h + * @file bitset_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__BITSET_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__BITSET_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "bitset_struct.hpp" @@ -53,14 +53,14 @@ class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~bitset_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_BITSET_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__BITSET_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx index 0cf11b79410..5fd82c272bc 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx @@ -58,7 +58,7 @@ void register_ColorBitset_type_identifier( uint16_t position_red = 0; BitsetMemberFlag flags_red = 0; uint8_t bitcount_red = 3; - TypeKind holder_type_red = TK_BYTE; + TypeKind holder_type_red = TK_UINT8; CommonBitfield common_red = TypeObjectUtils::build_common_bitfield(position_red, flags_red, bitcount_red, holder_type_red); eprosima::fastcdr::optional member_ann_builtin_red; ann_custom_ColorBitset.reset(); diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp index 57c4ef7315d..dae00edc87d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_bitset_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__BITSET_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp index f1cb9210ba2..98e9d53386a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ -#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ +#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_HPP +#define FAST_DDS_GENERATED__CHAR_SEQUENCE_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp index 11d7c4bd848..a1d9b9ad755 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ -#define _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP +#define FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP #include "char_sequence.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp index 756dc0bd977..ef63929e280 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ -#define _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP +#define FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP #include "char_sequenceCdrAux.hpp" @@ -114,5 +114,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCECDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx index 297c28c835f..c066f9e0b1d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "char_sequencePubSubTypes.h" +#include "char_sequencePubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ char_sequencePubSubType::~char_sequencePubSubType() } bool char_sequencePubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - char_sequence* p_type = static_cast(data); + const char_sequence* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool char_sequencePubSubType::deserialize( } std::function char_sequencePubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function char_sequencePubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void char_sequencePubSubType::deleteData( } bool char_sequencePubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool char_sequencePubSubType::getKey( return false; } - char_sequence* p_type = static_cast(data); + const char_sequence* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.hpp index 4441dba08d3..90af7267056 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file char_sequencePubSubTypes.h + * @file char_sequencePubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "char_sequence.hpp" @@ -53,14 +53,14 @@ class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~char_sequencePubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp index 7167bf5a0d0..45d4779e6b8 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_char_sequence_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp index 044a0055e98..1f7a722b187 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ -#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ +#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_HPP +#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp index ee7758a8ef4..d50851767e1 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP +#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP #include "complex_nested_arrays.hpp" @@ -63,5 +63,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp index 43e2c0e86ee..6744f03ef0a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP +#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP #include "complex_nested_arraysCdrAux.hpp" @@ -374,5 +374,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYSCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx index 3f8ef309915..25169cfa13f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "complex_nested_arraysPubSubTypes.h" +#include "complex_nested_arraysPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ ThirdLevelElementPubSubType::~ThirdLevelElementPubSubType() } bool ThirdLevelElementPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - ThirdLevelElement* p_type = static_cast(data); + const ThirdLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool ThirdLevelElementPubSubType::deserialize( } std::function ThirdLevelElementPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function ThirdLevelElementPubSubType::getSerializedSizeProvider eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void ThirdLevelElementPubSubType::deleteData( } bool ThirdLevelElementPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool ThirdLevelElementPubSubType::getKey( return false; } - ThirdLevelElement* p_type = static_cast(data); + const ThirdLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ SecondLevelElementPubSubType::~SecondLevelElementPubSubType() } bool SecondLevelElementPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - SecondLevelElement* p_type = static_cast(data); + const SecondLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool SecondLevelElementPubSubType::deserialize( } std::function SecondLevelElementPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function SecondLevelElementPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void SecondLevelElementPubSubType::deleteData( } bool SecondLevelElementPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool SecondLevelElementPubSubType::getKey( return false; } - SecondLevelElement* p_type = static_cast(data); + const SecondLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -443,11 +443,11 @@ FirstLevelElementPubSubType::~FirstLevelElementPubSubType() } bool FirstLevelElementPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FirstLevelElement* p_type = static_cast(data); + const FirstLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -519,7 +519,7 @@ bool FirstLevelElementPubSubType::deserialize( } std::function FirstLevelElementPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -536,7 +536,7 @@ std::function FirstLevelElementPubSubType::getSerializedSizeProvider eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -559,7 +559,7 @@ void FirstLevelElementPubSubType::deleteData( } bool FirstLevelElementPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -568,7 +568,7 @@ bool FirstLevelElementPubSubType::getKey( return false; } - FirstLevelElement* p_type = static_cast(data); + const FirstLevelElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -636,11 +636,11 @@ complex_nested_arraysPubSubType::~complex_nested_arraysPubSubType() } bool complex_nested_arraysPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - complex_nested_arrays* p_type = static_cast(data); + const complex_nested_arrays* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -712,7 +712,7 @@ bool complex_nested_arraysPubSubType::deserialize( } std::function complex_nested_arraysPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -729,7 +729,7 @@ std::function complex_nested_arraysPubSubType::getSerializedSizeProv eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -752,7 +752,7 @@ void complex_nested_arraysPubSubType::deleteData( } bool complex_nested_arraysPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -761,7 +761,7 @@ bool complex_nested_arraysPubSubType::getKey( return false; } - complex_nested_arrays* p_type = static_cast(data); + const complex_nested_arrays* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp similarity index 87% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp index c13439c6e2c..578f1555e40 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file complex_nested_arraysPubSubTypes.h + * @file complex_nested_arraysPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "complex_nested_arrays.hpp" @@ -53,14 +53,14 @@ class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~ThirdLevelElementPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp eProsima_user_DllExport ~SecondLevelElementPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,7 +215,7 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -235,14 +235,14 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FirstLevelElementPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -251,17 +251,17 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -288,7 +288,7 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -306,7 +306,7 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -326,14 +326,14 @@ class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicData eProsima_user_DllExport ~complex_nested_arraysPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -342,17 +342,17 @@ class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicData void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -379,7 +379,7 @@ class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicData } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -397,10 +397,10 @@ class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicData #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp index b575368deb8..aec5bb21e0a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP #include @@ -89,4 +89,4 @@ eProsima_user_DllExport void register_complex_nested_arrays_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp index 233d3ec45ef..3e39c0433c7 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_ENUM_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__ENUM_STRUCT_HPP +#define FAST_DDS_GENERATED__ENUM_STRUCT_HPP #include #include @@ -53,7 +53,7 @@ * @brief This class represents the enumeration ColorEnum defined by the user in the IDL file. * @ingroup enum_struct */ -enum class ColorEnum : uint32_t +enum class ColorEnum : int32_t { RED, GREEN, diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp index 9e1aa3673f6..285c5fc7be5 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_HPP #include "enum_struct.hpp" @@ -43,5 +43,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp index 28ac17b0ff5..8a43f231676 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_IPP #include "enum_structCdrAux.hpp" @@ -122,5 +122,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_ENUM_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__ENUM_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx index 179fd591e64..a742fab72a9 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "enum_structPubSubTypes.h" +#include "enum_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ enum_structPubSubType::~enum_structPubSubType() } bool enum_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - enum_struct* p_type = static_cast(data); + const enum_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool enum_structPubSubType::deserialize( } std::function enum_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function enum_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void enum_structPubSubType::deleteData( } bool enum_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool enum_structPubSubType::getKey( return false; } - enum_struct* p_type = static_cast(data); + const enum_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.hpp index 435b7600694..b69dda7e02d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file enum_structPubSubTypes.h + * @file enum_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__ENUM_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__ENUM_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "enum_struct.hpp" @@ -53,14 +53,14 @@ class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~enum_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_ENUM_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__ENUM_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp index 288179a215a..70026eb9ddf 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_enum_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__ENUM_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp index 886b11d2008..8d591917d4f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_HPP +#define FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp index b70ed7741ea..825c56074be 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_HPP #include "extensibility_struct.hpp" @@ -63,5 +63,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp index 48cf7f1a445..4f2f6158aa5 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_IPP #include "extensibility_structCdrAux.hpp" @@ -358,5 +358,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__EXTENSIBILITY_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx index 43ef557bf1b..b783cbdbcca 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "extensibility_structPubSubTypes.h" +#include "extensibility_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ FinalStructPubSubType::~FinalStructPubSubType() } bool FinalStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FinalStruct* p_type = static_cast(data); + const FinalStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool FinalStructPubSubType::deserialize( } std::function FinalStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function FinalStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void FinalStructPubSubType::deleteData( } bool FinalStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool FinalStructPubSubType::getKey( return false; } - FinalStruct* p_type = static_cast(data); + const FinalStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ MutableStructPubSubType::~MutableStructPubSubType() } bool MutableStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - MutableStruct* p_type = static_cast(data); + const MutableStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool MutableStructPubSubType::deserialize( } std::function MutableStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function MutableStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void MutableStructPubSubType::deleteData( } bool MutableStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool MutableStructPubSubType::getKey( return false; } - MutableStruct* p_type = static_cast(data); + const MutableStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -443,11 +443,11 @@ AppendableStructPubSubType::~AppendableStructPubSubType() } bool AppendableStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - AppendableStruct* p_type = static_cast(data); + const AppendableStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -519,7 +519,7 @@ bool AppendableStructPubSubType::deserialize( } std::function AppendableStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -536,7 +536,7 @@ std::function AppendableStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -559,7 +559,7 @@ void AppendableStructPubSubType::deleteData( } bool AppendableStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -568,7 +568,7 @@ bool AppendableStructPubSubType::getKey( return false; } - AppendableStruct* p_type = static_cast(data); + const AppendableStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -636,11 +636,11 @@ extensibility_structPubSubType::~extensibility_structPubSubType() } bool extensibility_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - extensibility_struct* p_type = static_cast(data); + const extensibility_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -712,7 +712,7 @@ bool extensibility_structPubSubType::deserialize( } std::function extensibility_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -729,7 +729,7 @@ std::function extensibility_structPubSubType::getSerializedSizeProvi eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -752,7 +752,7 @@ void extensibility_structPubSubType::deleteData( } bool extensibility_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -761,7 +761,7 @@ bool extensibility_structPubSubType::getKey( return false; } - extensibility_struct* p_type = static_cast(data); + const extensibility_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp similarity index 87% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp index 9debe862be5..4c2ddfd9e3c 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file extensibility_structPubSubTypes.h + * @file extensibility_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "extensibility_struct.hpp" @@ -86,14 +86,14 @@ class FinalStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FinalStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -102,17 +102,17 @@ class FinalStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -139,9 +139,9 @@ class FinalStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { - if(data_representation == eprosima::fastdds::dds::DataRepresentationId_t::XCDR2_DATA_REPRESENTATION) + if (data_representation == eprosima::fastdds::dds::DataRepresentationId_t::XCDR2_DATA_REPRESENTATION) { return is_plain_xcdrv2_impl(); } @@ -163,7 +163,7 @@ class FinalStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; private: @@ -199,14 +199,14 @@ class MutableStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~MutableStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -215,17 +215,17 @@ class MutableStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -252,7 +252,7 @@ class MutableStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -270,7 +270,7 @@ class MutableStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -290,14 +290,14 @@ class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~AppendableStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -306,17 +306,17 @@ class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -343,7 +343,7 @@ class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -361,7 +361,7 @@ class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -381,14 +381,14 @@ class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataT eProsima_user_DllExport ~extensibility_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -397,17 +397,17 @@ class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataT void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -434,7 +434,7 @@ class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataT } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -452,10 +452,10 @@ class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataT #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp index a6636cc6246..b3a41baa9fc 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -89,4 +89,4 @@ eProsima_user_DllExport void register_extensibility_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__EXTENSIBILITY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp index 983bb95d5bd..641f52d909c 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ -#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ +#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_HPP +#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp index 432e90292a2..d41f390ba7a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ -#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP +#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP #include "float_bounded_sequence.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp index 9903c5579b5..a167cf15144 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ -#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP +#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP #include "float_bounded_sequenceCdrAux.hpp" @@ -114,5 +114,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCECDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx index 1d4ead5615c..8c70ebedadf 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "float_bounded_sequencePubSubTypes.h" +#include "float_bounded_sequencePubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ float_bounded_sequencePubSubType::~float_bounded_sequencePubSubType() } bool float_bounded_sequencePubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - float_bounded_sequence* p_type = static_cast(data); + const float_bounded_sequence* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool float_bounded_sequencePubSubType::deserialize( } std::function float_bounded_sequencePubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function float_bounded_sequencePubSubType::getSerializedSizePro eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void float_bounded_sequencePubSubType::deleteData( } bool float_bounded_sequencePubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool float_bounded_sequencePubSubType::getKey( return false; } - float_bounded_sequence* p_type = static_cast(data); + const float_bounded_sequence* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp index 9d4387779c7..ffc3557f881 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file float_bounded_sequencePubSubTypes.h + * @file float_bounded_sequencePubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "float_bounded_sequence.hpp" @@ -53,14 +53,14 @@ class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDat eProsima_user_DllExport ~float_bounded_sequencePubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDat void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDat } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDat #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp index bdf598769b3..78dab6b6f08 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_float_bounded_sequence_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp index 282793dd764..27ca777dbc3 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ -#define _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ +#ifndef FAST_DDS_GENERATED__HELLO_WORLD_HPP +#define FAST_DDS_GENERATED__HELLO_WORLD_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp index 80a73b13314..4837eee8281 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP +#define FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP #include "hello_world.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp index 1f22846bccd..fd4e9f07348 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP +#define FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP #include "hello_worldCdrAux.hpp" @@ -122,5 +122,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_HELLO_WORLDCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx index 7cdb1683a54..f57610d0497 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "hello_worldPubSubTypes.h" +#include "hello_worldPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ hello_worldPubSubType::~hello_worldPubSubType() } bool hello_worldPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - hello_world* p_type = static_cast(data); + const hello_world* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool hello_worldPubSubType::deserialize( } std::function hello_worldPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function hello_worldPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void hello_worldPubSubType::deleteData( } bool hello_worldPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool hello_worldPubSubType::getKey( return false; } - hello_world* p_type = static_cast(data); + const hello_world* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.hpp index df55176d36c..47a4baa30ac 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file hello_worldPubSubTypes.h + * @file hello_worldPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "hello_world.hpp" @@ -53,14 +53,14 @@ class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~hello_worldPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_HELLO_WORLD_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp index dcf5d1a65c0..d0a80dd88e3 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_hello_world_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp index 6d475fde287..7a58ed499c3 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_HPP +#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp index 7e91fa43e98..b492934e2c2 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP #include "inheritance_struct.hpp" @@ -77,5 +77,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp index fab1a6a0c65..3c4cfbe15f7 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP #include "inheritance_structCdrAux.hpp" @@ -614,5 +614,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx index b8dfb4fcbc9..900c630868b 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "inheritance_structPubSubTypes.h" +#include "inheritance_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ GreatgrandfatherStructPubSubType::~GreatgrandfatherStructPubSubType() } bool GreatgrandfatherStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - GreatgrandfatherStruct* p_type = static_cast(data); + const GreatgrandfatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool GreatgrandfatherStructPubSubType::deserialize( } std::function GreatgrandfatherStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function GreatgrandfatherStructPubSubType::getSerializedSizePro eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void GreatgrandfatherStructPubSubType::deleteData( } bool GreatgrandfatherStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool GreatgrandfatherStructPubSubType::getKey( return false; } - GreatgrandfatherStruct* p_type = static_cast(data); + const GreatgrandfatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ GrandfatherStructPubSubType::~GrandfatherStructPubSubType() } bool GrandfatherStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - GrandfatherStruct* p_type = static_cast(data); + const GrandfatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool GrandfatherStructPubSubType::deserialize( } std::function GrandfatherStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function GrandfatherStructPubSubType::getSerializedSizeProvider eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void GrandfatherStructPubSubType::deleteData( } bool GrandfatherStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool GrandfatherStructPubSubType::getKey( return false; } - GrandfatherStruct* p_type = static_cast(data); + const GrandfatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -443,11 +443,11 @@ FatherStructPubSubType::~FatherStructPubSubType() } bool FatherStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FatherStruct* p_type = static_cast(data); + const FatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -519,7 +519,7 @@ bool FatherStructPubSubType::deserialize( } std::function FatherStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -536,7 +536,7 @@ std::function FatherStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -559,7 +559,7 @@ void FatherStructPubSubType::deleteData( } bool FatherStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -568,7 +568,7 @@ bool FatherStructPubSubType::getKey( return false; } - FatherStruct* p_type = static_cast(data); + const FatherStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -636,11 +636,11 @@ SonStructPubSubType::~SonStructPubSubType() } bool SonStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - SonStruct* p_type = static_cast(data); + const SonStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -712,7 +712,7 @@ bool SonStructPubSubType::deserialize( } std::function SonStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -729,7 +729,7 @@ std::function SonStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -752,7 +752,7 @@ void SonStructPubSubType::deleteData( } bool SonStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -761,7 +761,7 @@ bool SonStructPubSubType::getKey( return false; } - SonStruct* p_type = static_cast(data); + const SonStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -829,11 +829,11 @@ GrandsonStructPubSubType::~GrandsonStructPubSubType() } bool GrandsonStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - GrandsonStruct* p_type = static_cast(data); + const GrandsonStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -905,7 +905,7 @@ bool GrandsonStructPubSubType::deserialize( } std::function GrandsonStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -922,7 +922,7 @@ std::function GrandsonStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -945,7 +945,7 @@ void GrandsonStructPubSubType::deleteData( } bool GrandsonStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -954,7 +954,7 @@ bool GrandsonStructPubSubType::getKey( return false; } - GrandsonStruct* p_type = static_cast(data); + const GrandsonStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -1022,11 +1022,11 @@ inheritance_structPubSubType::~inheritance_structPubSubType() } bool inheritance_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - inheritance_struct* p_type = static_cast(data); + const inheritance_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -1098,7 +1098,7 @@ bool inheritance_structPubSubType::deserialize( } std::function inheritance_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -1115,7 +1115,7 @@ std::function inheritance_structPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -1138,7 +1138,7 @@ void inheritance_structPubSubType::deleteData( } bool inheritance_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -1147,7 +1147,7 @@ bool inheritance_structPubSubType::getKey( return false; } - inheritance_struct* p_type = static_cast(data); + const inheritance_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp similarity index 88% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp index 8a1b5a54e42..aabd0cf204d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file inheritance_structPubSubTypes.h + * @file inheritance_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "inheritance_struct.hpp" @@ -53,14 +53,14 @@ class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDat eProsima_user_DllExport ~GreatgrandfatherStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDat void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDat } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDat #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~GrandfatherStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,7 +215,7 @@ class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -235,14 +235,14 @@ class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FatherStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -251,17 +251,17 @@ class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -288,7 +288,7 @@ class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -306,7 +306,7 @@ class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -326,14 +326,14 @@ class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~SonStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -342,17 +342,17 @@ class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -379,7 +379,7 @@ class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -397,7 +397,7 @@ class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -417,14 +417,14 @@ class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~GrandsonStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -433,17 +433,17 @@ class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -470,7 +470,7 @@ class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -488,7 +488,7 @@ class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -508,14 +508,14 @@ class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp eProsima_user_DllExport ~inheritance_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -524,17 +524,17 @@ class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -561,7 +561,7 @@ class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -579,10 +579,10 @@ class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp index cece8aff483..4bba954636c 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -113,4 +113,4 @@ eProsima_user_DllExport void register_inheritance_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp index 5b03474991b..620ebce6914 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp index 9974cd2e26e..a92fb5c4afb 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_HPP #include "key_struct.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp index 15330eb2b1b..c12fe281c65 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP #include "key_structCdrAux.hpp" @@ -134,5 +134,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_KEY_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx index 4adcc1d420f..f6a91da5a35 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "key_structPubSubTypes.h" +#include "key_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ key_structPubSubType::~key_structPubSubType() } bool key_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - key_struct* p_type = static_cast(data); + const key_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool key_structPubSubType::deserialize( } std::function key_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function key_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void key_structPubSubType::deleteData( } bool key_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool key_structPubSubType::getKey( return false; } - key_struct* p_type = static_cast(data); + const key_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.hpp index 59f101ea154..fcab3a5870e 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file key_structPubSubTypes.h + * @file key_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "key_struct.hpp" @@ -53,14 +53,14 @@ class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~key_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_KEY_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp index e920230d5ff..4d141ebf93a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_key_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp index bbc4bdc89c5..cb2ed629ccb 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_MAP_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__MAP_STRUCT_HPP +#define FAST_DDS_GENERATED__MAP_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp index be6fde96e3c..bb78ac3b1e6 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_HPP #include "map_struct.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp index e49ea33b9f0..2fc10980476 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_IPP #include "map_structCdrAux.hpp" @@ -114,5 +114,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_MAP_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__MAP_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx index 464284052f8..4b3396a9db9 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "map_structPubSubTypes.h" +#include "map_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ map_structPubSubType::~map_structPubSubType() } bool map_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - map_struct* p_type = static_cast(data); + const map_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool map_structPubSubType::deserialize( } std::function map_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function map_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void map_structPubSubType::deleteData( } bool map_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool map_structPubSubType::getKey( return false; } - map_struct* p_type = static_cast(data); + const map_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.hpp index 72cd07deca5..d9edf34089d 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file map_structPubSubTypes.h + * @file map_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__MAP_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__MAP_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "map_struct.hpp" @@ -53,14 +53,14 @@ class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~map_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_MAP_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__MAP_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp index c0af3f4f51c..6a1a1e1df1a 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_map_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__MAP_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp index f4f172391c2..41f53fd9e5c 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_HPP +#define FAST_DDS_GENERATED__NESTED_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp index 49b144ef728..4c2cf3198cb 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP #include "nested_struct.hpp" @@ -77,5 +77,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp index 29d9eaeda4e..404af3c8ac0 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP #include "nested_structCdrAux.hpp" @@ -526,5 +526,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_NESTED_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx index dbd9522d3a8..109072bb202 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "nested_structPubSubTypes.h" +#include "nested_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ FirstStructPubSubType::~FirstStructPubSubType() } bool FirstStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FirstStruct* p_type = static_cast(data); + const FirstStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool FirstStructPubSubType::deserialize( } std::function FirstStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function FirstStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void FirstStructPubSubType::deleteData( } bool FirstStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool FirstStructPubSubType::getKey( return false; } - FirstStruct* p_type = static_cast(data); + const FirstStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -250,11 +250,11 @@ SecondStructPubSubType::~SecondStructPubSubType() } bool SecondStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - SecondStruct* p_type = static_cast(data); + const SecondStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -326,7 +326,7 @@ bool SecondStructPubSubType::deserialize( } std::function SecondStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -343,7 +343,7 @@ std::function SecondStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -366,7 +366,7 @@ void SecondStructPubSubType::deleteData( } bool SecondStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -375,7 +375,7 @@ bool SecondStructPubSubType::getKey( return false; } - SecondStruct* p_type = static_cast(data); + const SecondStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -443,11 +443,11 @@ ThirdStructPubSubType::~ThirdStructPubSubType() } bool ThirdStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - ThirdStruct* p_type = static_cast(data); + const ThirdStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -519,7 +519,7 @@ bool ThirdStructPubSubType::deserialize( } std::function ThirdStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -536,7 +536,7 @@ std::function ThirdStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -559,7 +559,7 @@ void ThirdStructPubSubType::deleteData( } bool ThirdStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -568,7 +568,7 @@ bool ThirdStructPubSubType::getKey( return false; } - ThirdStruct* p_type = static_cast(data); + const ThirdStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -636,11 +636,11 @@ FourthStructPubSubType::~FourthStructPubSubType() } bool FourthStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FourthStruct* p_type = static_cast(data); + const FourthStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -712,7 +712,7 @@ bool FourthStructPubSubType::deserialize( } std::function FourthStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -729,7 +729,7 @@ std::function FourthStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -752,7 +752,7 @@ void FourthStructPubSubType::deleteData( } bool FourthStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -761,7 +761,7 @@ bool FourthStructPubSubType::getKey( return false; } - FourthStruct* p_type = static_cast(data); + const FourthStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -829,11 +829,11 @@ FifthStructPubSubType::~FifthStructPubSubType() } bool FifthStructPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - FifthStruct* p_type = static_cast(data); + const FifthStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -905,7 +905,7 @@ bool FifthStructPubSubType::deserialize( } std::function FifthStructPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -922,7 +922,7 @@ std::function FifthStructPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -945,7 +945,7 @@ void FifthStructPubSubType::deleteData( } bool FifthStructPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -954,7 +954,7 @@ bool FifthStructPubSubType::getKey( return false; } - FifthStruct* p_type = static_cast(data); + const FifthStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), @@ -1022,11 +1022,11 @@ nested_structPubSubType::~nested_structPubSubType() } bool nested_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - nested_struct* p_type = static_cast(data); + const nested_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -1098,7 +1098,7 @@ bool nested_structPubSubType::deserialize( } std::function nested_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -1115,7 +1115,7 @@ std::function nested_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -1138,7 +1138,7 @@ void nested_structPubSubType::deleteData( } bool nested_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -1147,7 +1147,7 @@ bool nested_structPubSubType::getKey( return false; } - nested_struct* p_type = static_cast(data); + const nested_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.hpp similarity index 88% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.hpp index e523eb63521..a86ece59af0 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file nested_structPubSubTypes.h + * @file nested_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "nested_struct.hpp" @@ -53,14 +53,14 @@ class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FirstStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,7 +124,7 @@ class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -144,14 +144,14 @@ class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~SecondStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -160,17 +160,17 @@ class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -197,7 +197,7 @@ class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -215,7 +215,7 @@ class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -235,14 +235,14 @@ class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~ThirdStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -251,17 +251,17 @@ class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -288,7 +288,7 @@ class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -306,7 +306,7 @@ class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -326,14 +326,14 @@ class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FourthStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -342,17 +342,17 @@ class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -379,7 +379,7 @@ class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -397,7 +397,7 @@ class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -417,14 +417,14 @@ class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~FifthStructPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -433,17 +433,17 @@ class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -470,7 +470,7 @@ class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -488,7 +488,7 @@ class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; @@ -508,14 +508,14 @@ class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~nested_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -524,17 +524,17 @@ class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -561,7 +561,7 @@ class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -579,10 +579,10 @@ class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp index 313def76200..2117b2f0127 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -113,4 +113,4 @@ eProsima_user_DllExport void register_nested_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp index 7ae80c45853..a78917adcfb 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ -#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ +#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_HPP +#define FAST_DDS_GENERATED__NUMERIC_ARRAY_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp index a058c1a8b0b..a00c7007b8f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP +#define FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP #include "numeric_array.hpp" @@ -42,5 +42,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp index 41c1c7ad72a..a6c384ed34e 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP +#define FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP #include "numeric_arrayCdrAux.hpp" @@ -114,5 +114,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAYCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx index 47db4f96f2d..66b7701c2d5 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "numeric_arrayPubSubTypes.h" +#include "numeric_arrayPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ numeric_arrayPubSubType::~numeric_arrayPubSubType() } bool numeric_arrayPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - numeric_array* p_type = static_cast(data); + const numeric_array* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool numeric_arrayPubSubType::deserialize( } std::function numeric_arrayPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function numeric_arrayPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void numeric_arrayPubSubType::deleteData( } bool numeric_arrayPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool numeric_arrayPubSubType::getKey( return false; } - numeric_array* p_type = static_cast(data); + const numeric_array* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.hpp index 235d77b7993..d65cea0be06 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file numeric_arrayPubSubTypes.h + * @file numeric_arrayPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "numeric_array.hpp" @@ -53,14 +53,14 @@ class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~numeric_arrayPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp index 05a27bf5b81..b6219fd7034 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP #include @@ -53,4 +53,4 @@ eProsima_user_DllExport void register_numeric_array_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash b/test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash new file mode 100644 index 00000000000..aab6d044350 --- /dev/null +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash @@ -0,0 +1,21 @@ +#!/bin/bash + +# Define the root directory containing the folders +root_dir="/home/daniel/Documents/eprosima/dynamic_type_idl/src/fastdds/test/unittest/dds/xtypes/type_conversion/types/type_objects" + +# Iterate through each folder in the root directory +for folder in "$root_dir"/*/; do + # Extract the folder name + folder_name=$(basename "$folder") + + # Change to the folder + cd "$folder" || exit + + # Run the commands + cp "../../idls/${folder_name}.idl" . + /home/daniel/Documents/fastddsgen/scripts/fastddsgen -replace "${folder_name}.idl" + rm "${folder_name}.idl" + + # Change back to the root directory + cd "$root_dir" || exit +done diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp index 20aad0b7c30..4ec3a99c441 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_HPP_ -#define _FAST_DDS_GENERATED_UNION_STRUCT_HPP_ +#ifndef FAST_DDS_GENERATED__UNION_STRUCT_HPP +#define FAST_DDS_GENERATED__UNION_STRUCT_HPP #include #include diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp index 19fe3c1b448..6a6d3b85a03 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ -#define _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ +#ifndef FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_HPP #include "union_struct.hpp" @@ -43,5 +43,5 @@ eProsima_user_DllExport void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_HPP_ +#endif // FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp index 3472d9e6988..372fcc5ac61 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ -#define _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ +#ifndef FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_IPP #include "union_structCdrAux.hpp" @@ -273,5 +273,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // _FAST_DDS_GENERATED_UNION_STRUCTCDRAUX_IPP_ +#endif // FAST_DDS_GENERATED__UNION_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx index fb3bc458a64..7a2ddc63316 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx @@ -19,7 +19,7 @@ * This file was generated by the tool fastddsgen. */ -#include "union_structPubSubTypes.h" +#include "union_structPubSubTypes.hpp" #include #include @@ -57,11 +57,11 @@ union_structPubSubType::~union_structPubSubType() } bool union_structPubSubType::serialize( - void* data, + const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - union_struct* p_type = static_cast(data); + const union_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -133,7 +133,7 @@ bool union_structPubSubType::deserialize( } std::function union_structPubSubType::getSerializedSizeProvider( - void* data, + const void* const data, DataRepresentationId_t data_representation) { return [data, data_representation]() -> uint32_t @@ -150,7 +150,7 @@ std::function union_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -173,7 +173,7 @@ void union_structPubSubType::deleteData( } bool union_structPubSubType::getKey( - void* data, + const void* const data, InstanceHandle_t* handle, bool force_md5) { @@ -182,7 +182,7 @@ bool union_structPubSubType::getKey( return false; } - union_struct* p_type = static_cast(data); + const union_struct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h rename to test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.hpp index 310df478642..29fdef4c231 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.h +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.hpp @@ -13,21 +13,21 @@ // limitations under the License. /*! - * @file union_structPubSubTypes.h + * @file union_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ -#define _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ +#ifndef FAST_DDS_GENERATED__UNION_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__UNION_STRUCT_PUBSUBTYPES_HPP #include #include -#include -#include -#include +#include +#include +#include #include "union_struct.hpp" @@ -53,14 +53,14 @@ class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType eProsima_user_DllExport ~union_structPubSubType() override; eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload) override { return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport bool serialize( - void* data, + const void* const data, eprosima::fastdds::rtps::SerializedPayload_t* payload, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; @@ -69,17 +69,17 @@ class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType void* data) override; eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data) override + const void* const data) override { return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); } eProsima_user_DllExport std::function getSerializedSizeProvider( - void* data, + const void* const data, eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; eProsima_user_DllExport bool getKey( - void* data, + const void* const data, eprosima::fastdds::rtps::InstanceHandle_t* ihandle, bool force_md5 = false) override; @@ -106,7 +106,7 @@ class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType } eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override { static_cast(data_representation); return false; @@ -124,10 +124,10 @@ class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType #endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - MD5 m_md5; + eprosima::fastdds::MD5 m_md5; unsigned char* m_keyBuffer; }; -#endif // _FAST_DDS_GENERATED_UNION_STRUCT_PUBSUBTYPES_H_ +#endif // FAST_DDS_GENERATED__UNION_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp index 6e1e1dbf58f..6949f933e1f 100644 --- a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp @@ -19,8 +19,8 @@ * This file was generated by the tool fastddsgen. */ -#ifndef _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ -#define _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#ifndef FAST_DDS_GENERATED__UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -65,4 +65,4 @@ eProsima_user_DllExport void register_union_struct_type_identifier( #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // _FAST_DDS_GENERATED_UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP_ +#endif // FAST_DDS_GENERATED__UNION_STRUCT_TYPE_OBJECT_SUPPORT_HPP From 8991b45284732133ceeadbcd9be487a058dded30 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 4 Jul 2024 14:40:23 +0200 Subject: [PATCH 36/52] Review - Restructure the code & regenerate types Signed-off-by: tempate --- src/cpp/CMakeLists.txt | 1 + src/cpp/fastdds/xtypes/CMakeLists.txt | 2 + .../idl/dynamic_type_idl.cpp} | 2 + .../idl/dynamic_type_idl.hpp} | 2 - src/cpp/fastdds/xtypes/utils.cpp | 2 +- test/unittest/CMakeLists.txt | 1 - .../dds/xtypes/serializers/CMakeLists.txt | 1 + .../idl}/CMakeLists.txt | 21 ++---- .../idl/DynTypeIDLTests.cpp} | 8 +-- .../idl}/types/all_types.hpp | 72 +++++++++---------- .../types/gen}/alias_struct/alias_struct.hpp | 0 .../gen}/alias_struct/alias_structCdrAux.hpp | 0 .../gen}/alias_struct/alias_structCdrAux.ipp | 0 .../alias_struct/alias_structPubSubTypes.cxx | 0 .../alias_struct/alias_structPubSubTypes.hpp | 0 .../alias_structTypeObjectSupport.cxx | 0 .../alias_structTypeObjectSupport.hpp | 0 .../arrays_and_sequences.hpp | 0 .../arrays_and_sequencesCdrAux.hpp | 0 .../arrays_and_sequencesCdrAux.ipp | 0 .../arrays_and_sequencesPubSubTypes.cxx | 0 .../arrays_and_sequencesPubSubTypes.hpp | 0 .../arrays_and_sequencesTypeObjectSupport.cxx | 0 .../arrays_and_sequencesTypeObjectSupport.hpp | 0 .../basic_array_struct/basic_array_struct.hpp | 0 .../basic_array_structCdrAux.hpp | 0 .../basic_array_structCdrAux.ipp | 0 .../basic_array_structPubSubTypes.cxx | 0 .../basic_array_structPubSubTypes.hpp | 0 .../basic_array_structTypeObjectSupport.cxx | 0 .../basic_array_structTypeObjectSupport.hpp | 0 .../types/gen}/basic_struct/basic_struct.hpp | 0 .../gen}/basic_struct/basic_structCdrAux.hpp | 0 .../gen}/basic_struct/basic_structCdrAux.ipp | 0 .../basic_struct/basic_structPubSubTypes.cxx | 0 .../basic_struct/basic_structPubSubTypes.hpp | 0 .../basic_structTypeObjectSupport.cxx | 0 .../basic_structTypeObjectSupport.hpp | 0 .../gen}/bitmask_struct/bitmask_struct.hpp | 0 .../bitmask_struct/bitmask_structCdrAux.hpp | 0 .../bitmask_struct/bitmask_structCdrAux.ipp | 0 .../bitmask_structPubSubTypes.cxx | 0 .../bitmask_structPubSubTypes.hpp | 0 .../bitmask_structTypeObjectSupport.cxx | 0 .../bitmask_structTypeObjectSupport.hpp | 0 .../gen}/bitset_struct/bitset_struct.hpp | 0 .../bitset_struct/bitset_structCdrAux.hpp | 0 .../bitset_struct/bitset_structCdrAux.ipp | 0 .../bitset_structPubSubTypes.cxx | 0 .../bitset_structPubSubTypes.hpp | 0 .../bitset_structTypeObjectSupport.cxx | 0 .../bitset_structTypeObjectSupport.hpp | 0 .../gen}/char_sequence/char_sequence.hpp | 0 .../char_sequence/char_sequenceCdrAux.hpp | 0 .../char_sequence/char_sequenceCdrAux.ipp | 0 .../char_sequencePubSubTypes.cxx | 0 .../char_sequencePubSubTypes.hpp | 0 .../char_sequenceTypeObjectSupport.cxx | 0 .../char_sequenceTypeObjectSupport.hpp | 0 .../complex_nested_arrays.hpp | 0 .../complex_nested_arraysCdrAux.hpp | 0 .../complex_nested_arraysCdrAux.ipp | 0 .../complex_nested_arraysPubSubTypes.cxx | 0 .../complex_nested_arraysPubSubTypes.hpp | 0 ...complex_nested_arraysTypeObjectSupport.cxx | 0 ...complex_nested_arraysTypeObjectSupport.hpp | 0 .../types/gen}/enum_struct/enum_struct.hpp | 0 .../gen}/enum_struct/enum_structCdrAux.hpp | 0 .../gen}/enum_struct/enum_structCdrAux.ipp | 0 .../enum_struct/enum_structPubSubTypes.cxx | 0 .../enum_struct/enum_structPubSubTypes.hpp | 0 .../enum_structTypeObjectSupport.cxx | 0 .../enum_structTypeObjectSupport.hpp | 0 .../extensibility_struct.hpp | 0 .../extensibility_structCdrAux.hpp | 0 .../extensibility_structCdrAux.ipp | 0 .../extensibility_structPubSubTypes.cxx | 0 .../extensibility_structPubSubTypes.hpp | 0 .../extensibility_structTypeObjectSupport.cxx | 0 .../extensibility_structTypeObjectSupport.hpp | 0 .../float_bounded_sequence.hpp | 0 .../float_bounded_sequenceCdrAux.hpp | 0 .../float_bounded_sequenceCdrAux.ipp | 0 .../float_bounded_sequencePubSubTypes.cxx | 0 .../float_bounded_sequencePubSubTypes.hpp | 0 ...loat_bounded_sequenceTypeObjectSupport.cxx | 0 ...loat_bounded_sequenceTypeObjectSupport.hpp | 0 .../types/gen}/hello_world/hello_world.hpp | 0 .../gen}/hello_world/hello_worldCdrAux.hpp | 0 .../gen}/hello_world/hello_worldCdrAux.ipp | 0 .../hello_world/hello_worldPubSubTypes.cxx | 0 .../hello_world/hello_worldPubSubTypes.hpp | 0 .../hello_worldTypeObjectSupport.cxx | 0 .../hello_worldTypeObjectSupport.hpp | 0 .../inheritance_struct/inheritance_struct.hpp | 0 .../inheritance_structCdrAux.hpp | 0 .../inheritance_structCdrAux.ipp | 0 .../inheritance_structPubSubTypes.cxx | 0 .../inheritance_structPubSubTypes.hpp | 0 .../inheritance_structTypeObjectSupport.cxx | 0 .../inheritance_structTypeObjectSupport.hpp | 0 .../idl/types/gen}/key_struct/key_struct.hpp | 0 .../gen}/key_struct/key_structCdrAux.hpp | 0 .../gen}/key_struct/key_structCdrAux.ipp | 0 .../gen}/key_struct/key_structPubSubTypes.cxx | 0 .../gen}/key_struct/key_structPubSubTypes.hpp | 0 .../key_structTypeObjectSupport.cxx | 0 .../key_structTypeObjectSupport.hpp | 0 .../idl/types/gen}/map_struct/map_struct.hpp | 0 .../gen}/map_struct/map_structCdrAux.hpp | 0 .../gen}/map_struct/map_structCdrAux.ipp | 0 .../gen}/map_struct/map_structPubSubTypes.cxx | 0 .../gen}/map_struct/map_structPubSubTypes.hpp | 0 .../map_structTypeObjectSupport.cxx | 0 .../map_structTypeObjectSupport.hpp | 0 .../gen}/nested_struct/nested_struct.hpp | 0 .../nested_struct/nested_structCdrAux.hpp | 0 .../nested_struct/nested_structCdrAux.ipp | 0 .../nested_structPubSubTypes.cxx | 0 .../nested_structPubSubTypes.hpp | 0 .../nested_structTypeObjectSupport.cxx | 0 .../nested_structTypeObjectSupport.hpp | 0 .../gen}/numeric_array/numeric_array.hpp | 0 .../numeric_array/numeric_arrayCdrAux.hpp | 0 .../numeric_array/numeric_arrayCdrAux.ipp | 0 .../numeric_arrayPubSubTypes.cxx | 0 .../numeric_arrayPubSubTypes.hpp | 0 .../numeric_arrayTypeObjectSupport.cxx | 0 .../numeric_arrayTypeObjectSupport.hpp | 0 .../idl/types/gen}/regenerate_types.bash | 0 .../types/gen}/union_struct/union_struct.hpp | 0 .../gen}/union_struct/union_structCdrAux.hpp | 0 .../gen}/union_struct/union_structCdrAux.ipp | 0 .../union_struct/union_structPubSubTypes.cxx | 0 .../union_struct/union_structPubSubTypes.hpp | 0 .../union_structTypeObjectSupport.cxx | 0 .../union_structTypeObjectSupport.hpp | 0 .../idl}/types/idls/alias_struct.idl | 0 .../idl}/types/idls/arrays_and_sequences.idl | 0 .../idl}/types/idls/basic_array_struct.idl | 0 .../idl}/types/idls/basic_struct.idl | 0 .../idl}/types/idls/bitmask_struct.idl | 0 .../idl}/types/idls/bitset_struct.idl | 0 .../idl}/types/idls/char_sequence.idl | 0 .../idl}/types/idls/complex_nested_arrays.idl | 0 .../idl}/types/idls/enum_struct.idl | 0 .../idl}/types/idls/extensibility_struct.idl | 0 .../types/idls/float_bounded_sequence.idl | 0 .../idl}/types/idls/hello_world.idl | 0 .../idl}/types/idls/inheritance_struct.idl | 0 .../idl}/types/idls/key_struct.idl | 0 .../idl}/types/idls/map_struct.idl | 0 .../idl}/types/idls/nested_struct.idl | 0 .../idl}/types/idls/numeric_array.idl | 0 .../idl}/types/idls/union_struct.idl | 0 155 files changed, 54 insertions(+), 58 deletions(-) rename src/cpp/fastdds/xtypes/{type_conversion/dyn_type_tree.ipp => serializers/idl/dynamic_type_idl.cpp} (99%) rename src/cpp/fastdds/xtypes/{type_conversion/dyn_type_tree.hpp => serializers/idl/dynamic_type_idl.hpp} (99%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/CMakeLists.txt (86%) rename test/unittest/dds/xtypes/{type_conversion/DynamicTypeSerializationTests.cpp => serializers/idl/DynTypeIDLTests.cpp} (93%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/all_types.hpp (68%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/alias_struct/alias_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequences.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_array_struct/basic_array_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/basic_struct/basic_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitmask_struct/bitmask_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/bitset_struct/bitset_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequence.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequenceCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequenceCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequencePubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequencePubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequenceTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/char_sequence/char_sequenceTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arrays.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/enum_struct/enum_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/extensibility_struct/extensibility_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequence.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_world.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/hello_world/hello_worldTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/inheritance_struct/inheritance_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/key_struct/key_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/map_struct/map_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/nested_struct/nested_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_array.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/numeric_array/numeric_arrayTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/regenerate_types.bash (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_struct.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structCdrAux.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structCdrAux.ipp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structPubSubTypes.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structPubSubTypes.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structTypeObjectSupport.cxx (100%) rename test/unittest/dds/xtypes/{type_conversion/types/type_objects => serializers/idl/types/gen}/union_struct/union_structTypeObjectSupport.hpp (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/alias_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/arrays_and_sequences.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/basic_array_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/basic_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/bitmask_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/bitset_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/char_sequence.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/complex_nested_arrays.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/enum_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/extensibility_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/float_bounded_sequence.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/hello_world.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/inheritance_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/key_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/map_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/nested_struct.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/numeric_array.idl (100%) rename test/unittest/dds/xtypes/{type_conversion => serializers/idl}/types/idls/union_struct.idl (100%) diff --git a/src/cpp/CMakeLists.txt b/src/cpp/CMakeLists.txt index 045a63b3fae..21896a47f92 100644 --- a/src/cpp/CMakeLists.txt +++ b/src/cpp/CMakeLists.txt @@ -104,6 +104,7 @@ set(${PROJECT_NAME}_source_files fastdds/xtypes/dynamic_types/TypeDescriptorImpl.cpp fastdds/xtypes/dynamic_types/VerbatimTextDescriptorImpl.cpp fastdds/xtypes/exception/Exception.cpp + fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp fastdds/xtypes/serializers/json/dynamic_data_json.cpp fastdds/xtypes/type_representation/dds_xtypes_typeobjectPubSubTypes.cxx fastdds/xtypes/type_representation/TypeObjectRegistry.cpp diff --git a/src/cpp/fastdds/xtypes/CMakeLists.txt b/src/cpp/fastdds/xtypes/CMakeLists.txt index 394a6928fb7..c55ce04fad1 100644 --- a/src/cpp/fastdds/xtypes/CMakeLists.txt +++ b/src/cpp/fastdds/xtypes/CMakeLists.txt @@ -78,6 +78,8 @@ target_sources(fastdds-xtypes-dynamic-types-impl INTERFACE dynamic_types/TypeDescriptorImpl.hpp dynamic_types/VerbatimTextDescriptorImpl.cpp dynamic_types/VerbatimTextDescriptorImpl.hpp + serializers/idl/dynamic_type_idl.cpp + serializers/idl/dynamic_type_idl.hpp serializers/json/dynamic_data_json.cpp serializers/json/dynamic_data_json.hpp utils.cpp diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp similarity index 99% rename from src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp rename to src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index b98c8622456..68421fc9f08 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.ipp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -20,10 +20,12 @@ #include #include +#include #include #include #include +#include "dynamic_type_idl.hpp" namespace eprosima { namespace fastdds { diff --git a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp similarity index 99% rename from src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp rename to src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp index 02ce801bfc6..ef4abc0a564 100644 --- a/src/cpp/fastdds/xtypes/type_conversion/dyn_type_tree.hpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp @@ -247,6 +247,4 @@ ReturnCode_t get_default_type_kind( } // fastdds } // eprosima -#include "dyn_type_tree.ipp" - #endif // _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 0112a68cd0d..74cb8eee0a4 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -40,7 +40,7 @@ #include "dynamic_types/DynamicDataImpl.hpp" #include "serializers/json/dynamic_data_json.hpp" -#include "type_conversion/dyn_type_tree.hpp" +#include "serializers/idl/dynamic_type_idl.hpp" #include "utils/collections/TreeNode.hpp" diff --git a/test/unittest/CMakeLists.txt b/test/unittest/CMakeLists.txt index 6910ae040c8..dcf6151a3ba 100644 --- a/test/unittest/CMakeLists.txt +++ b/test/unittest/CMakeLists.txt @@ -24,7 +24,6 @@ add_subdirectory(dds/subscriber) add_subdirectory(dds/topic) add_subdirectory(dds/topic/DDSSQLFilter) add_subdirectory(dds/xtypes/serializers) -add_subdirectory(dds/xtypes/type_conversion) add_subdirectory(dds/xtypes/type_representation) add_subdirectory(logging) add_subdirectory(rtps/attributes) diff --git a/test/unittest/dds/xtypes/serializers/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/CMakeLists.txt index ef7c1507986..04eaea02b54 100644 --- a/test/unittest/dds/xtypes/serializers/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/CMakeLists.txt @@ -12,4 +12,5 @@ # See the License for the specific language governing permissions and # limitations under the License. +add_subdirectory(idl) add_subdirectory(json) diff --git a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt similarity index 86% rename from test/unittest/dds/xtypes/type_conversion/CMakeLists.txt rename to test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index 09915c3fd7a..ae46e939720 100644 --- a/test/unittest/dds/xtypes/type_conversion/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -86,34 +86,27 @@ configure_file( COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE - DynamicTypeSerializationTests.cpp + DynTypeIDLTests.cpp ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/xtypes/utils.cpp) -file(GLOB DATATYPE_SOURCES_CPP "types/type_objects/**/*.cpp") -file(GLOB DATATYPE_SOURCES_CXX "types/type_objects/**/*.cxx") - -set( - DATATYPE_SOURCES - ${DATATYPE_SOURCES_CPP} - ${DATATYPE_SOURCES_CXX} - ) +file(GLOB DATATYPE_SOURCES "types/gen/**/*.cxx") if(WIN32) add_definitions(-D_WIN32_WINNT=0x0601) endif() -add_executable(DynamicTypeSerializationTests ${RESOURCEDYNTYPETOIDLTESTS_SOURCE} ${DATATYPE_SOURCES}) -target_compile_definitions(DynamicTypeSerializationTests PRIVATE +add_executable(DynTypeIDLTests ${RESOURCEDYNTYPETOIDLTESTS_SOURCE} ${DATATYPE_SOURCES}) +target_compile_definitions(DynTypeIDLTests PRIVATE $<$>,$>:__DEBUG> $<$:__INTERNALDEBUG> # Internal debug activated. ) -target_include_directories(DynamicTypeSerializationTests PRIVATE +target_include_directories(DynTypeIDLTests PRIVATE ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include ${PROJECT_SOURCE_DIR}/src/cpp ) -target_link_libraries(DynamicTypeSerializationTests +target_link_libraries(DynTypeIDLTests fastcdr fastdds GTest::gtest ${CMAKE_DL_LIBS}) -gtest_discover_tests(DynamicTypeSerializationTests SOURCES ${TYPEOBJECTUTILSTESTS_SOURCE}) +gtest_discover_tests(DynTypeIDLTests SOURCES ${TYPEOBJECTUTILSTESTS_SOURCE}) diff --git a/test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp similarity index 93% rename from test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp rename to test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index f46225a3fbc..4855aa82df7 100644 --- a/test/unittest/dds/xtypes/type_conversion/DynamicTypeSerializationTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -32,7 +32,7 @@ using namespace eprosima; using namespace eprosima::fastdds::dds; -class DynamicTypeSerializationTests : public ::testing::TestWithParam +class DynTypeIDLTests : public ::testing::TestWithParam { public: @@ -67,7 +67,7 @@ class DynamicTypeSerializationTests : public ::testing::TestWithParam -#include "type_objects/alias_struct/alias_struct.hpp" -#include "type_objects/alias_struct/alias_structPubSubTypes.hpp" +#include "gen/alias_struct/alias_struct.hpp" +#include "gen/alias_struct/alias_structPubSubTypes.hpp" -#include "type_objects/arrays_and_sequences/arrays_and_sequences.hpp" -#include "type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp" +#include "gen/arrays_and_sequences/arrays_and_sequences.hpp" +#include "gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp" -#include "type_objects/basic_array_struct/basic_array_struct.hpp" -#include "type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp" +#include "gen/basic_array_struct/basic_array_struct.hpp" +#include "gen/basic_array_struct/basic_array_structPubSubTypes.hpp" -#include "type_objects/basic_struct/basic_struct.hpp" -#include "type_objects/basic_struct/basic_structPubSubTypes.hpp" +#include "gen/basic_struct/basic_struct.hpp" +#include "gen/basic_struct/basic_structPubSubTypes.hpp" -#include "type_objects/bitmask_struct/bitmask_struct.hpp" -#include "type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp" +#include "gen/bitmask_struct/bitmask_struct.hpp" +#include "gen/bitmask_struct/bitmask_structPubSubTypes.hpp" -#include "type_objects/bitset_struct/bitset_struct.hpp" -#include "type_objects/bitset_struct/bitset_structPubSubTypes.hpp" +#include "gen/bitset_struct/bitset_struct.hpp" +#include "gen/bitset_struct/bitset_structPubSubTypes.hpp" -#include "type_objects/char_sequence/char_sequence.hpp" -#include "type_objects/char_sequence/char_sequencePubSubTypes.hpp" +#include "gen/char_sequence/char_sequence.hpp" +#include "gen/char_sequence/char_sequencePubSubTypes.hpp" -#include "type_objects/complex_nested_arrays/complex_nested_arrays.hpp" -#include "type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp" +#include "gen/complex_nested_arrays/complex_nested_arrays.hpp" +#include "gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp" -#include "type_objects/enum_struct/enum_struct.hpp" -#include "type_objects/enum_struct/enum_structPubSubTypes.hpp" +#include "gen/enum_struct/enum_struct.hpp" +#include "gen/enum_struct/enum_structPubSubTypes.hpp" -#include "type_objects/extensibility_struct/extensibility_struct.hpp" -#include "type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp" +#include "gen/extensibility_struct/extensibility_struct.hpp" +#include "gen/extensibility_struct/extensibility_structPubSubTypes.hpp" -#include "type_objects/float_bounded_sequence/float_bounded_sequence.hpp" -#include "type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp" +#include "gen/float_bounded_sequence/float_bounded_sequence.hpp" +#include "gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp" -#include "type_objects/hello_world/hello_world.hpp" -#include "type_objects/hello_world/hello_worldPubSubTypes.hpp" +#include "gen/hello_world/hello_world.hpp" +#include "gen/hello_world/hello_worldPubSubTypes.hpp" -#include "type_objects/inheritance_struct/inheritance_struct.hpp" -#include "type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp" +#include "gen/inheritance_struct/inheritance_struct.hpp" +#include "gen/inheritance_struct/inheritance_structPubSubTypes.hpp" -#include "type_objects/key_struct/key_struct.hpp" -#include "type_objects/key_struct/key_structPubSubTypes.hpp" +#include "gen/key_struct/key_struct.hpp" +#include "gen/key_struct/key_structPubSubTypes.hpp" -#include "type_objects/map_struct/map_struct.hpp" -#include "type_objects/map_struct/map_structPubSubTypes.hpp" +#include "gen/map_struct/map_struct.hpp" +#include "gen/map_struct/map_structPubSubTypes.hpp" -#include "type_objects/nested_struct/nested_struct.hpp" -#include "type_objects/nested_struct/nested_structPubSubTypes.hpp" +#include "gen/nested_struct/nested_struct.hpp" +#include "gen/nested_struct/nested_structPubSubTypes.hpp" -#include "type_objects/numeric_array/numeric_array.hpp" -#include "type_objects/numeric_array/numeric_arrayPubSubTypes.hpp" +#include "gen/numeric_array/numeric_array.hpp" +#include "gen/numeric_array/numeric_arrayPubSubTypes.hpp" -#include "type_objects/union_struct/union_struct.hpp" -#include "type_objects/union_struct/union_structPubSubTypes.hpp" +#include "gen/union_struct/union_struct.hpp" +#include "gen/union_struct/union_structPubSubTypes.hpp" namespace test { diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/alias_struct/alias_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequences.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_array_struct/basic_array_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/basic_struct/basic_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitmask_struct/bitmask_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/bitset_struct/bitset_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequence.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequencePubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/char_sequence/char_sequenceTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arrays.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/enum_struct/enum_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/extensibility_struct/extensibility_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequence.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_world.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/hello_world/hello_worldTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/inheritance_struct/inheritance_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/key_struct/key_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/map_struct/map_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/nested_struct/nested_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_array.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/numeric_array/numeric_arrayTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash b/test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/regenerate_types.bash rename to test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx diff --git a/test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/type_objects/union_struct/union_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/alias_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/alias_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/alias_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/arrays_and_sequences.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/basic_array_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/basic_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/bitmask_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/bitmask_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/bitmask_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/bitset_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/bitset_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/bitset_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/char_sequence.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/complex_nested_arrays.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/enum_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/enum_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/enum_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/extensibility_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/float_bounded_sequence.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/hello_world.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/inheritance_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/key_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/map_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/nested_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/numeric_array.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl diff --git a/test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl similarity index 100% rename from test/unittest/dds/xtypes/type_conversion/types/idls/union_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl From 6b4ba360a85c1602c1dd2c5e8d8de817459629f0 Mon Sep 17 00:00:00 2001 From: tempate Date: Fri, 5 Jul 2024 09:23:19 +0200 Subject: [PATCH 37/52] Review - Apply suggestions Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 8 +- .../serializers/idl/dynamic_type_idl.cpp | 636 +++++++++--------- .../serializers/idl/dynamic_type_idl.hpp | 108 +-- src/cpp/fastdds/xtypes/utils.cpp | 58 +- .../dds/xtypes/serializers/idl/CMakeLists.txt | 12 + .../serializers/idl/DynTypeIDLTests.cpp | 40 +- .../serializers/idl/types/all_types.hpp | 180 +++-- .../map_bounded_struct/map_bounded_struct.hpp | 191 ++++++ .../map_bounded_structCdrAux.hpp | 46 ++ .../map_bounded_structCdrAux.ipp | 118 ++++ .../map_bounded_structPubSubTypes.cxx | 229 +++++++ .../map_bounded_structPubSubTypes.hpp | 133 ++++ .../map_bounded_structTypeObjectSupport.cxx | 167 +++++ .../map_bounded_structTypeObjectSupport.hpp | 56 ++ .../idl/types/gen/map_struct/map_struct.hpp | 218 +++++- .../types/gen/map_struct/map_structCdrAux.hpp | 9 +- .../types/gen/map_struct/map_structCdrAux.ipp | 90 ++- .../gen/map_struct/map_structPubSubTypes.cxx | 193 ++++++ .../gen/map_struct/map_structPubSubTypes.hpp | 91 +++ .../map_structTypeObjectSupport.cxx | 206 +++++- .../map_structTypeObjectSupport.hpp | 12 + .../multi_array_struct/multi_array_struct.hpp | 386 +++++++++++ .../multi_array_structCdrAux.hpp | 53 ++ .../multi_array_structCdrAux.ipp | 210 ++++++ .../multi_array_structPubSubTypes.cxx | 422 ++++++++++++ .../multi_array_structPubSubTypes.hpp | 224 ++++++ .../multi_array_structTypeObjectSupport.cxx | 255 +++++++ .../multi_array_structTypeObjectSupport.hpp | 68 ++ .../idl/types/gen/regenerate_types.bash | 21 - .../types/gen/string_struct/string_struct.hpp | 331 +++++++++ .../gen/string_struct/string_structCdrAux.hpp | 46 ++ .../gen/string_struct/string_structCdrAux.ipp | 142 ++++ .../string_structPubSubTypes.cxx | 229 +++++++ .../string_structPubSubTypes.hpp | 133 ++++ .../string_structTypeObjectSupport.cxx | 222 ++++++ .../string_structTypeObjectSupport.hpp | 56 ++ .../types/gen/union_struct/union_struct.hpp | 636 +++++++++++++----- .../gen/union_struct/union_structCdrAux.hpp | 2 +- .../gen/union_struct/union_structCdrAux.ipp | 201 ++++-- .../union_structTypeObjectSupport.cxx | 365 ++++++---- .../union_structTypeObjectSupport.hpp | 16 +- .../idl/types/idls/map_bounded_struct.idl | 4 + .../serializers/idl/types/idls/map_struct.idl | 8 +- .../idl/types/idls/multi_array_struct.idl | 11 + .../idl/types/idls/string_struct.idl | 7 + .../idl/types/idls/union_struct.idl | 24 +- 46 files changed, 5918 insertions(+), 955 deletions(-) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index 4b9da03badb..f160fa39597 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -38,14 +38,14 @@ enum class DynamicDataJsonFormat }; /** - * @brief Serializes a DynamicType into an IDL schema. + * @brief Serializes a DynamicType into its IDL representation. * * @param [in] dynamic_type The DynamicType to serialize. - * @param [out] output The IDL schema. + * @param [in,out] output The IDL representation. */ FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( - const traits::ref_type& dynamic_type, - std::string& output) noexcept; + const DynamicType::_ref_type& dynamic_type, + std::ostream& output) noexcept; /*! * Serializes a @ref DynamicData into a JSON object, which is then dumped into an \c std::ostream. diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index 68421fc9f08..434ff344031 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include #include #include #include @@ -31,11 +32,12 @@ namespace eprosima { namespace fastdds { namespace dds { +using namespace eprosima::utilities::collections; + constexpr auto TYPE_OPENING = "\n{\n"; constexpr auto TYPE_CLOSURE = "};\n"; constexpr auto TAB_SEPARATOR = " "; - ////////////////////////// // DYNAMIC TYPE TO TREE // ////////////////////////// @@ -43,64 +45,72 @@ constexpr auto TAB_SEPARATOR = " "; ReturnCode_t dyn_type_to_tree( const DynamicType::_ref_type& type, const std::string& member_name, - utilities::collections::TreeNode& node) noexcept + TreeNode& node) noexcept { ReturnCode_t ret = RETCODE_OK; - switch (type->get_kind()) + const auto kind = type->get_kind(); + + if (kind == TK_STRUCTURE) { - case TK_STRUCTURE: - { // If is struct, the call is recursive. // Create new tree node - utilities::collections::TreeNode parent(member_name, type->get_name().to_string(), type); + TreeNode parent(member_name, type->get_name().to_string(), type); // Get its base class TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } // Add base class as a new branch const auto base_type = type_descriptor->base_type(); + std::uint32_t first_member = 0; - if (base_type != nullptr) + if (nullptr != base_type) { - utilities::collections::TreeNode child; + TreeNode child; ret = dyn_type_to_tree(base_type, "PARENT", child); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } child.info.is_base = true; - // Add each member with its name as a new child in a branch (recursion) + // If the struct is derived from a base, the first members of the struct are the members of the base. + first_member = base_type->get_member_count(); + parent.add_branch(child); } - // Get all members of this struct - std::vector> members_by_name; - ret = get_members_sorted(type, members_by_name); - - if (ret != RETCODE_OK) + // Add each member as a new branch except for the members of its base class + for (std::uint32_t index = first_member; index < type->get_member_count(); index++) { - return ret; - } + traits::ref_type member; + ret = type->get_member_by_index(member, index); - for (const auto& member : members_by_name) - { - const auto& member_name = member.first; - const auto& member_descriptor = member.second; + if (RETCODE_OK != ret) + { + return ret; + } + + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member->get_descriptor(member_descriptor); + + if (RETCODE_OK != ret) + { + return ret; + } - utilities::collections::TreeNode child; - ret = dyn_type_to_tree(member_descriptor->type(), member_name, child); + TreeNode child; + ret = dyn_type_to_tree(member_descriptor->type(), member_descriptor->name().to_string(), child); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -112,65 +122,102 @@ ReturnCode_t dyn_type_to_tree( } node = parent; - break; + } + else + { + std::stringstream idl; + ret = type_kind_to_idl(type, idl); + + if (RETCODE_OK != ret) + { + return ret; } - case TK_ARRAY: - case TK_SEQUENCE: + + node = TreeNode(member_name, idl.str(), type); + + if (kind == TK_ARRAY || kind == TK_SEQUENCE) { - // If container (array or struct) has exactly one branch + // If container (array or sequence) has exactly one branch // Calculate child branch DynamicType::_ref_type internal_type; ret = container_internal_type(type, internal_type); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - std::string internal_str; - ret = type_kind_to_str(type, internal_str); + TreeNode child; + ret = dyn_type_to_tree(internal_type, "CONTAINER_MEMBER", child); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - // Create this node - utilities::collections::TreeNode container(member_name, internal_str, type); - // Add branch - ret = dyn_type_to_tree(internal_type, "CONTAINER_MEMBER", node); + node.add_branch(child); + } + else if (kind == TK_MAP) + { + // Add value branch + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - container.add_branch(node); - - node = container; - break; - } - default: - { - std::string type_str; - ret = type_kind_to_str(type, type_str); + TreeNode value; + ret = dyn_type_to_tree(type_descriptor->element_type(), "VALUE", value); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - node = utilities::collections::TreeNode(member_name, type_str, type); - break; + node.add_branch(value); + } + else if (kind == TK_UNION) + { + // Add each member as a new branch + for (std::uint32_t index = 1; index < type->get_member_count(); index++) + { + traits::ref_type member; + ret = type->get_member_by_index(member, index); + + if (RETCODE_OK != ret) + { + return ret; + } + + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member->get_descriptor(member_descriptor); + + if (RETCODE_OK != ret) + { + return ret; + } + + TreeNode child; + ret = dyn_type_to_tree(member_descriptor->type(), member_descriptor->name().to_string(), child); + + if (RETCODE_OK != ret) + { + return ret; + } + + node.add_branch(child); + } } } return ret; } -ReturnCode_t type_kind_to_str( +ReturnCode_t type_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& type_str) noexcept + std::ostream& idl) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -178,102 +225,98 @@ ReturnCode_t type_kind_to_str( { case TK_BOOLEAN: { - type_str = "boolean"; + idl << "boolean"; break; } case TK_BYTE: { - type_str = "octet"; + idl << "octet"; break; } case TK_INT8: { - type_str = "char"; + idl << "char"; break; } case TK_INT16: { - type_str = "short"; + idl << "short"; break; } case TK_INT32: { - type_str = "long"; + idl << "long"; break; } case TK_INT64: { - type_str = "long long"; + idl << "long long"; break; } case TK_UINT8: { - type_str = "unsigned char"; + idl << "unsigned char"; break; } case TK_UINT16: { - type_str = "unsigned short"; + idl << "unsigned short"; break; } case TK_UINT32: { - type_str = "unsigned long"; + idl << "unsigned long"; break; } case TK_UINT64: { - type_str = "unsigned long long"; + idl << "unsigned long long"; break; } case TK_FLOAT32: { - type_str = "float"; + idl << "float"; break; } case TK_FLOAT64: { - type_str = "double"; + idl << "double"; break; } case TK_FLOAT128: { - type_str = "long double"; + idl << "long double"; break; } case TK_CHAR8: { - type_str = "char"; + idl << "char"; break; } case TK_CHAR16: { - type_str = "wchar"; + idl << "wchar"; break; } case TK_STRING8: - { - type_str = "string"; - break; - } case TK_STRING16: { - type_str = "wstring"; + ret = string_kind_to_idl(dyn_type, idl); break; } case TK_ARRAY: { - ret = array_kind_to_str(dyn_type, type_str); + ret = array_kind_to_idl(dyn_type, idl); break; } case TK_SEQUENCE: { - ret = sequence_kind_to_str(dyn_type, type_str); + ret = sequence_kind_to_idl(dyn_type, idl); break; } case TK_MAP: { - ret = map_kind_to_str(dyn_type, type_str); + ret = map_kind_to_idl(dyn_type, idl); break; } case TK_ALIAS: @@ -283,7 +326,7 @@ ReturnCode_t type_kind_to_str( case TK_STRUCTURE: case TK_UNION: { - type_str = dyn_type->get_name().to_string(); + idl << dyn_type->get_name().to_string(); break; } case TK_NONE: @@ -301,29 +344,25 @@ ReturnCode_t type_kind_to_str( return ret; } -ReturnCode_t array_kind_to_str( +ReturnCode_t array_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& array_str) noexcept + std::ostream& idl) noexcept { - if (dyn_type->get_kind() != TK_ARRAY) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an array."); - return RETCODE_BAD_PARAMETER; - } + assert(dyn_type->get_kind() == TK_ARRAY); ReturnCode_t ret = RETCODE_OK; DynamicType::_ref_type internal_type; ret = container_internal_type(dyn_type, internal_type); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - ret = type_kind_to_str(internal_type, array_str); + ret = type_kind_to_idl(internal_type, idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -331,168 +370,144 @@ ReturnCode_t array_kind_to_str( BoundSeq bounds; ret = container_size(dyn_type, bounds); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } for (const auto& bound : bounds) { - array_str += "["; - array_str += std::to_string(bound); - array_str += "]"; + idl << "[" << std::to_string(bound) << "]"; } return ret; } -ReturnCode_t map_kind_to_str( +ReturnCode_t map_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& map_str) noexcept + std::ostream& idl) noexcept { - if (dyn_type->get_kind() != TK_MAP) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a map."); - return RETCODE_BAD_PARAMETER; - } + assert(dyn_type->get_kind() == TK_MAP); ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = dyn_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - std::string key_str; + idl << "map<"; + const auto key_type = type_descriptor->key_element_type(); - ret = type_kind_to_str(key_type, key_str); + ret = type_kind_to_idl(key_type, idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - std::string value_str; + idl << ", "; + const auto value_type = type_descriptor->element_type(); - ret = type_kind_to_str(value_type, value_str); + ret = type_kind_to_idl(value_type, idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - std::stringstream ss; + BoundSeq bounds; + ret = container_size(dyn_type, bounds); - ss << "map<" << key_str << ", " << value_str << ">"; + if (RETCODE_OK != ret) + { + return ret; + } - map_str = ss.str(); + if (bounds.size() == 1) + { + idl << ", " << std::to_string(bounds[0]); + } + + idl << ">"; return ret; } -ReturnCode_t sequence_kind_to_str( +ReturnCode_t sequence_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& sequence_str) noexcept + std::ostream& idl) noexcept { - if (dyn_type->get_kind() != TK_SEQUENCE) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a sequence."); - return RETCODE_BAD_PARAMETER; - } + assert(dyn_type->get_kind() == TK_SEQUENCE); ReturnCode_t ret = RETCODE_OK; DynamicType::_ref_type internal_type; ret = container_internal_type(dyn_type, internal_type); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - ret = type_kind_to_str(internal_type, sequence_str); + idl << "sequence<"; - if (ret != RETCODE_OK) + ret = type_kind_to_idl(internal_type, idl); + + if (RETCODE_OK != ret) { return ret; } - sequence_str = "sequence<" + sequence_str; - BoundSeq bounds; ret = container_size(dyn_type, bounds); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - for (const auto& bound : bounds) + if (1 == bounds.size()) { - const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); - - if (bound != UNBOUNDED) - { - sequence_str += ", " + std::to_string(bound); - } + idl << ", " << std::to_string(bounds[0]); } - sequence_str += ">"; + idl << ">"; return ret; } -ReturnCode_t get_members_sorted( +ReturnCode_t string_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::vector>& result) noexcept + std::ostream& idl) noexcept { - ReturnCode_t ret = RETCODE_OK; + assert(dyn_type->get_kind() == TK_STRING8 || dyn_type->get_kind() == TK_STRING16); - // Skip the inherited members - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = dyn_type->get_descriptor(type_descriptor); + ReturnCode_t ret = RETCODE_OK; - if (ret != RETCODE_OK) + if (dyn_type->get_kind() == TK_STRING16) { - return ret; + idl << "wstring"; + } + else + { + idl << "string"; } - const auto base_type = type_descriptor->base_type(); - - std::uint32_t first_member = 0; + BoundSeq bounds; + ret = container_size(dyn_type, bounds); - if (base_type != nullptr) + if (RETCODE_OK != ret) { - // If the struct has a base type, the first member is the base type - first_member = base_type->get_member_count(); + return ret; } - // Collect its members - for (std::uint32_t index = first_member; index < dyn_type->get_member_count(); index++) + if (1 == bounds.size()) { - traits::ref_type member; - ret = dyn_type->get_member_by_index(member, index); - - if (ret != RETCODE_OK) - { - return ret; - } - - MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member->get_descriptor(member_descriptor); - - if (ret != RETCODE_OK) - { - return ret; - } - - result.emplace_back( - std::make_pair( - member_descriptor->name().to_string(), - std::move(member_descriptor))); + idl << "<" << std::to_string(bounds[0]) << ">"; } return ret; @@ -507,7 +522,7 @@ ReturnCode_t container_internal_type( TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = dyn_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -526,24 +541,30 @@ ReturnCode_t container_size( TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = dyn_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } bounds = type_descriptor->bound(); + static const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); + + if (1 == bounds.size() && UNBOUNDED == bounds[0]) + { + bounds.clear(); + } + return ret; } - ////////////////////////////// // DYNAMIC TYPE TREE TO IDL // ////////////////////////////// ReturnCode_t dyn_type_tree_to_idl( - const utilities::collections::TreeNode& root, - std::string& dyn_type_str) noexcept + const TreeNode& root, + std::ostream& idl) noexcept { ReturnCode_t ret = RETCODE_OK; @@ -559,39 +580,38 @@ ReturnCode_t dyn_type_tree_to_idl( continue; } - std::string kind_str; const auto kind = node.info.dynamic_type->get_kind(); switch (kind) { case TK_ALIAS: { - ret = alias_to_str(node, kind_str); + ret = alias_to_idl(node, idl); break; } case TK_BITMASK: { - ret = bitmask_to_str(node, kind_str); + ret = bitmask_to_idl(node, idl); break; } case TK_BITSET: { - ret = bitset_to_str(node, kind_str); + ret = bitset_to_idl(node, idl); break; } case TK_ENUM: { - ret = enum_to_str(node, kind_str); + ret = enum_to_idl(node, idl); break; } case TK_STRUCTURE: { - ret = struct_to_str(node, kind_str); + ret = struct_to_idl(node, idl); break; } case TK_UNION: { - ret = union_to_str(node, kind_str); + ret = union_to_idl(node, idl); break; } default: @@ -600,87 +620,74 @@ ReturnCode_t dyn_type_tree_to_idl( } } - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - dyn_type_str += kind_str + "\n"; + idl << "\n"; types_written.insert(node.info.type_kind_name); } // Write struct parent node at last, after all its dependencies - // NOTE: not a requirement for Foxglove IDL Parser, dependencies can be placed after parent - std::string struct_str; - ret = struct_to_str(root, struct_str); + ret = struct_to_idl(root, idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - dyn_type_str += struct_str; - return ret; } -ReturnCode_t alias_to_str( - const utilities::collections::TreeNode& node, - std::string& alias_str) noexcept +ReturnCode_t alias_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_ALIAS) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an alias."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_ALIAS); ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } + idl << "typedef "; + // Find the base type of the alias - std::string base_type_kind_str; - ret = type_kind_to_str(type_descriptor->base_type(), base_type_kind_str); + ret = type_kind_to_idl(type_descriptor->base_type(), idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - alias_str = "typedef "; - alias_str += base_type_kind_str + " "; - alias_str += type_descriptor->name().to_string() + ";\n"; + idl << " " << node.info.type_kind_name << ";\n"; return ret; } -ReturnCode_t bitmask_to_str( - const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept +ReturnCode_t bitmask_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_BITMASK) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitmask."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_BITMASK); ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - if (type_descriptor->bound().size() != 1) + if (1 != type_descriptor->bound().size()) { EPROSIMA_LOG_ERROR(DYN_TYPES, "Bitmask type must have exactly one bound."); return RETCODE_BAD_PARAMETER; @@ -690,12 +697,12 @@ ReturnCode_t bitmask_to_str( static constexpr std::uint32_t DEFAULT_BITMASK_SIZE = 32; const auto bitmask_size = type_descriptor->bound()[0]; - if (bitmask_size != DEFAULT_BITMASK_SIZE) + if (DEFAULT_BITMASK_SIZE != bitmask_size) { - bitset_str = "@bit_bound(" + std::to_string(bitmask_size) + ")\n"; + idl << "@bit_bound(" << std::to_string(bitmask_size) << ")\n"; } - bitset_str += "bitmask " + node.info.type_kind_name + TYPE_OPENING; + idl << "bitmask " << node.info.type_kind_name << TYPE_OPENING; const auto member_count = node.info.dynamic_type->get_member_count(); @@ -703,62 +710,58 @@ ReturnCode_t bitmask_to_str( for (std::uint32_t index = 0; index < member_count; index++) { - traits::ref_type member; + DynamicTypeMember::_ref_type member; ret = node.info.dynamic_type->get_member_by_index(member, index); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - bitset_str += TAB_SEPARATOR; + idl << TAB_SEPARATOR; // Annotation with the position const auto id = member->get_id(); if (id != pos) { - bitset_str += "@position(" + std::to_string(id) + ") "; + idl << "@position(" << std::to_string(id) << ") "; } - bitset_str += member->get_name().to_string(); + idl << member->get_name().to_string(); // Add comma if not last member if (index < member_count - 1) { - bitset_str += ","; + idl << ","; } - bitset_str += "\n"; + idl << "\n"; // The position is always sequential pos = id + 1; } // Close definition - bitset_str += TYPE_CLOSURE; + idl << TYPE_CLOSURE; return ret; } -ReturnCode_t bitset_to_str( - const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept +ReturnCode_t bitset_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_BITSET) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a bitset."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_BITSET); ReturnCode_t ret = RETCODE_OK; - bitset_str = "bitset " + node.info.type_kind_name + TYPE_OPENING; + idl << "bitset " << node.info.type_kind_name << TYPE_OPENING; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -773,7 +776,7 @@ ReturnCode_t bitset_to_str( traits::ref_type member; ret = node.info.dynamic_type->get_member_by_index(member, index); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -787,20 +790,15 @@ ReturnCode_t bitset_to_str( const auto bits = id - bits_set; bits_set += bits; - bitset_str += TAB_SEPARATOR; - bitset_str += "bitfield<"; - bitset_str += std::to_string(bits); - bitset_str += ">;\n"; + idl << TAB_SEPARATOR << "bitfield<" << std::to_string(bits) << ">;\n"; } - bitset_str += TAB_SEPARATOR; - bitset_str += "bitfield<"; - bitset_str += std::to_string(bits[index]); + idl << TAB_SEPARATOR << "bitfield<" << std::to_string(bits[index]); MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; ret = member->get_descriptor(member_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -808,7 +806,7 @@ ReturnCode_t bitset_to_str( TypeKind default_type_kind; ret = get_default_type_kind(bits[index], default_type_kind); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -817,76 +815,62 @@ ReturnCode_t bitset_to_str( // set it explicitly. if (member_descriptor->type()->get_kind() != default_type_kind) { - // The type of the bitfield is not the default type. Write it. - std::string type_str; - type_kind_to_str(member_descriptor->type(), type_str); + idl << ", "; - bitset_str += ", "; - bitset_str += type_str; + // The type of the bitfield is not the default type. Write it. + type_kind_to_idl(member_descriptor->type(), idl); } - bitset_str += "> "; - bitset_str += member->get_name().to_string(); - bitset_str += ";\n"; + idl << "> " << member->get_name().to_string() << ";\n"; bits_set += bits[index]; } // Close definition - bitset_str += TYPE_CLOSURE; + idl << TYPE_CLOSURE; return ret; } -ReturnCode_t enum_to_str( - const utilities::collections::TreeNode& node, - std::string& enum_str) noexcept +ReturnCode_t enum_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_ENUM) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not an enum."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_ENUM); ReturnCode_t ret = RETCODE_OK; - enum_str = "enum " + node.info.type_kind_name + TYPE_OPENING + TAB_SEPARATOR; + idl << "enum " << node.info.type_kind_name << TYPE_OPENING << TAB_SEPARATOR; for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) { traits::ref_type member; ret = node.info.dynamic_type->get_member_by_index(member, index); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - if (index != 0) + if (0 != index) { - enum_str += ",\n"; - enum_str += TAB_SEPARATOR; + idl << ",\n" << TAB_SEPARATOR; } - enum_str += member->get_name().to_string(); + idl << member->get_name().to_string(); } // Close definition - enum_str += "\n"; - enum_str += TYPE_CLOSURE; + idl << "\n" << TYPE_CLOSURE; return ret; } -ReturnCode_t struct_to_str( - const utilities::collections::TreeNode& node, - std::string& struct_str) noexcept +ReturnCode_t struct_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_STRUCTURE) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a struct."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_STRUCTURE); ReturnCode_t ret = RETCODE_OK; @@ -894,7 +878,7 @@ ReturnCode_t struct_to_str( TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } @@ -903,12 +887,12 @@ ReturnCode_t struct_to_str( { case ExtensibilityKind::FINAL: { - struct_str = "@extensibility(FINAL)\n"; + idl << "@extensibility(FINAL)\n"; break; } case ExtensibilityKind::MUTABLE: { - struct_str = "@extensibility(MUTABLE)\n"; + idl << "@extensibility(MUTABLE)\n"; break; } case ExtensibilityKind::APPENDABLE: @@ -924,23 +908,22 @@ ReturnCode_t struct_to_str( } // Add types name - struct_str += "struct " + node.info.type_kind_name; + idl << "struct " << node.info.type_kind_name; // Add inheritance - if (type_descriptor->base_type() != nullptr) + if (nullptr != type_descriptor->base_type()) { - std::string base_type_str; - ret = type_kind_to_str(type_descriptor->base_type(), base_type_str); + idl << " : "; + + ret = type_kind_to_idl(type_descriptor->base_type(), idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - - struct_str += " : " + base_type_str; } - struct_str += TYPE_OPENING; + idl << TYPE_OPENING; // Add struct attributes for (auto const& child : node.branches()) @@ -950,47 +933,43 @@ ReturnCode_t struct_to_str( continue; } - std::string child_str; - node_to_str(child.info, child_str); + node_to_idl(child.info, idl); - struct_str += child_str + ";\n"; + idl << ";\n"; } // Close definition - struct_str += TYPE_CLOSURE; + idl << TYPE_CLOSURE; return ret; } -ReturnCode_t union_to_str( - const utilities::collections::TreeNode& node, - std::string& union_str) noexcept +ReturnCode_t union_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - if (node.info.dynamic_type->get_kind() != TK_UNION) - { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Type is not a union."); - return RETCODE_BAD_PARAMETER; - } + assert(node.info.dynamic_type->get_kind() == TK_UNION); ReturnCode_t ret = RETCODE_OK; TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - std::string discriminant_type_str; - ret = type_kind_to_str(type_descriptor->discriminator_type(), discriminant_type_str); + idl << "union " << node.info.type_kind_name << " switch ("; - if (ret != RETCODE_OK) + ret = type_kind_to_idl(type_descriptor->discriminator_type(), idl); + + if (RETCODE_OK != ret) { return ret; } - union_str = "union " + node.info.type_kind_name + " switch (" + discriminant_type_str + ")" + TYPE_OPENING; + idl << ")" << TYPE_OPENING; for (std::uint32_t index = 1; index < node.info.dynamic_type->get_member_count(); index++) { @@ -1000,68 +979,57 @@ ReturnCode_t union_to_str( MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; ret = member->get_descriptor(member_descriptor); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } const auto labels = member_descriptor->label(); // WARNING: There might be casting issues as discriminant type is currently not taken into consideration - bool first_iter = true; for (const auto& label : labels) { - if (first_iter) - { - union_str += TAB_SEPARATOR; - } - else - { - union_str += " "; - } - - first_iter = false; + idl << TAB_SEPARATOR << "case " << std::to_string(label) << ":\n"; + } - union_str += "case " + std::to_string(label) + ":"; + if (member_descriptor->is_default_label()) + { + idl << TAB_SEPARATOR << "default:\n"; } - std::string member_str; - ret = type_kind_to_str(member_descriptor->type(), member_str); + idl << TAB_SEPARATOR << TAB_SEPARATOR; + + ret = type_kind_to_idl(member_descriptor->type(), idl); - if (ret != RETCODE_OK) + if (RETCODE_OK != ret) { return ret; } - union_str += "\n"; - union_str += TAB_SEPARATOR; - union_str += TAB_SEPARATOR; - union_str += member_str + " "; - union_str += member->get_name().to_string(); - union_str += ";\n"; + idl << " " << member->get_name().to_string() << ";\n"; } // Close definition - union_str += TYPE_CLOSURE; + idl << TYPE_CLOSURE; return ret; } -ReturnCode_t node_to_str( - const utilities::collections::TreeNode& node, - std::string& node_str) noexcept +ReturnCode_t node_to_idl( + const TreeNode& node, + std::ostream& idl) noexcept { - node_str = TAB_SEPARATOR; + idl << TAB_SEPARATOR; if (node.info.is_key) { - node_str += "@key "; + idl << "@key "; } - if (node.info.dynamic_type->get_kind() == TK_ARRAY) + if (TK_ARRAY == node.info.dynamic_type->get_kind()) { const auto dim_pos = node.info.type_kind_name.find("["); - if (dim_pos == std::string::npos) + if (std::string::npos == dim_pos) { EPROSIMA_LOG_ERROR(DYN_TYPES, "Array type name is not well formed."); return RETCODE_BAD_PARAMETER; @@ -1070,11 +1038,11 @@ ReturnCode_t node_to_str( const auto kind_name_str = node.info.type_kind_name.substr(0, dim_pos); const auto dim_str = node.info.type_kind_name.substr(dim_pos, std::string::npos); - node_str += kind_name_str + " " + node.info.member_name + dim_str; + idl << kind_name_str << " " << node.info.member_name << dim_str; } else { - node_str += node.info.type_kind_name + " " + node.info.member_name; + idl << node.info.type_kind_name << " " << node.info.member_name; } return RETCODE_OK; @@ -1106,7 +1074,7 @@ ReturnCode_t get_default_type_kind( } else { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Size is not supported."); + EPROSIMA_LOG_ERROR(DYN_TYPES, "Size " << size << " is not supported."); return RETCODE_BAD_PARAMETER; } diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp index ef4abc0a564..235b855a9f8 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp @@ -13,13 +13,13 @@ // limitations under the License. /*! - * @file dyn_type_tree.hpp + * @file dynamic_type_idl.hpp */ -#ifndef _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ -#define _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ +#ifndef FASTDDS_DDS_XTYPES_SERIALIZERS_IDL__DYNAMIC_TYPE_IDL_HPP +#define FASTDDS_DDS_XTYPES_SERIALIZERS_IDL__DYNAMIC_TYPE_IDL_HPP -#include +#include #include #include @@ -82,51 +82,51 @@ ReturnCode_t dyn_type_to_tree( * @brief Converts a DynamicType to a string. * * @param dyn_type The DynamicType to convert. - * @param type_str The string representation of the DynamicType. + * @param idl The idl representation of the DynamicType. */ -ReturnCode_t type_kind_to_str( +ReturnCode_t type_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& type_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a DynamicType of \c TK_ARRAY kind to a string. + * @brief Converts a DynamicType of \c TK_ARRAY kind to an idl. * * @param dyn_type The DynamicType kind to convert. * @param array_str The string representation of the DynamicType kind. */ -ReturnCode_t array_kind_to_str( +ReturnCode_t array_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& array_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a DynamicType of \c TK_MAP kind to a string. + * @brief Converts a DynamicType of \c TK_MAP kind to an idl. * * @param dyn_type The DynamicType to convert. - * @param map_str The string representation of the DynamicType. + * @param idl The idl representation of the DynamicType. */ -ReturnCode_t map_kind_to_str( +ReturnCode_t map_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& map_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a DynamicType of \c TK_SEQUENCE kind to a string. + * @brief Converts a DynamicType of \c TK_SEQUENCE kind to an idl. * * @param dyn_type The DynamicType to convert. - * @param sequence_str The string representation of the DynamicType. + * @param idl The idl representation of the DynamicType. */ -ReturnCode_t sequence_kind_to_str( +ReturnCode_t sequence_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::string& sequence_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Gathers the members of a DynamicType. + * @brief Converts a DynamicType of \c TK_STRING8 or \c TK_STRING16 kind to an idl. * - * @param dyn_type The DynamicType to gather the members from. - * @param result The vector of (name, member_descriptor) to store the members. + * @param dyn_type The DynamicType to convert. + * @param idl The idl representation of the DynamicType. */ -ReturnCode_t get_members_sorted( +ReturnCode_t string_kind_to_idl( const DynamicType::_ref_type& dyn_type, - std::vector>& result) noexcept; + std::ostream& idl) noexcept; /** * @brief Gathers the \c element_type of the DynamicType. @@ -154,84 +154,84 @@ ReturnCode_t container_size( ////////////////////////////// /** - * @brief Converts a tree to an IDL string. + * @brief Converts a tree to an IDL stream. * * @param root The root node of the tree. - * @param dyn_type_str The string representation of the tree. + * @param idl The idl representation of the tree. */ ReturnCode_t dyn_type_tree_to_idl( const utilities::collections::TreeNode& root, - std::string& dyn_type_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_ALIAS root to an IDL string. + * @brief Converts a tree with a \c TK_ALIAS root to an IDL stream. * * @param node The root node of the tree. - * @param alias_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t alias_to_str( +ReturnCode_t alias_to_idl( const utilities::collections::TreeNode& node, - std::string& alias_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_BITMASK root to an IDL string. + * @brief Converts a tree with a \c TK_BITMASK root to an IDL stream. * * @param node The root node of the tree. - * @param union_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t bitmask_to_str( +ReturnCode_t bitmask_to_idl( const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_BITSET root to an IDL string. + * @brief Converts a tree with a \c TK_BITSET root to an IDL stream. * * @param node The root node of the tree. - * @param union_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t bitset_to_str( +ReturnCode_t bitset_to_idl( const utilities::collections::TreeNode& node, - std::string& bitset_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_ENUM root to an IDL string. + * @brief Converts a tree with a \c TK_ENUM root to an IDL stream. * * @param node The root node of the tree. - * @param enum_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t enum_to_str( +ReturnCode_t enum_to_idl( const utilities::collections::TreeNode& node, - std::string& enum_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_STRUCTURE root to an IDL string. + * @brief Converts a tree with a \c TK_STRUCTURE root to an IDL stream. * * @param node The root node of the tree. - * @param struct_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t struct_to_str( +ReturnCode_t struct_to_idl( const utilities::collections::TreeNode& node, - std::string& struct_str) noexcept; + std::ostream& idl) noexcept; /** - * @brief Converts a tree with a \c TK_UNION root to an IDL string. + * @brief Converts a tree with a \c TK_UNION root to an IDL stream. * * @param node The root node of the tree. - * @param union_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t union_to_str( +ReturnCode_t union_to_idl( const utilities::collections::TreeNode& node, - std::string& union_str) noexcept; + std::ostream& idl) noexcept; /** * @brief Converts a simple tree to an IDL string. * * @param node The root node of the tree. - * @param node_str The string representation of the tree. + * @param idl The idl representation of the tree. */ -ReturnCode_t node_to_str( +ReturnCode_t node_to_idl( const utilities::collections::TreeNode& node, - std::string& node_str) noexcept; + std::ostream& idl) noexcept; /** * @brief Finds the default type kind for a variable with a given size. @@ -247,4 +247,4 @@ ReturnCode_t get_default_type_kind( } // fastdds } // eprosima -#endif // _FASTDDS_DDS_XTYPES_DYN_TYPE_TREE_HPP_ +#endif // FASTDDS_DDS_XTYPES_SERIALIZERS_IDL__DYNAMIC_TYPE_IDL_HPP diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 74cb8eee0a4..fbcfe16fec3 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -12,42 +12,43 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include -#include -#include #include -#include -#include -#include #include -#include #include -#include #include -#include -#include -#include -#include #include #include "dynamic_types/DynamicDataImpl.hpp" -#include "dynamic_types/DynamicTypeImpl.hpp" -#include "dynamic_types/DynamicTypeMemberImpl.hpp" -#include "dynamic_types/MemberDescriptorImpl.hpp" -#include "dynamic_types/TypeDescriptorImpl.hpp" - -#include "dynamic_types/DynamicDataImpl.hpp" -#include "serializers/json/dynamic_data_json.hpp" #include "serializers/idl/dynamic_type_idl.hpp" - +#include "serializers/json/dynamic_data_json.hpp" #include "utils/collections/TreeNode.hpp" +#include + + namespace eprosima { namespace fastdds { namespace dds { +ReturnCode_t idl_serialize( + const DynamicType::_ref_type& dynamic_type, + std::ostream& output) noexcept +{ + // Create a tree representation of the dynamic type + utilities::collections::TreeNode parent_type; + const auto ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); + + if (ret != RETCODE_OK) + { + return ret; + } + + // Serialize the tree to IDL + return dyn_type_tree_to_idl(parent_type, output); +} + ReturnCode_t json_serialize( const DynamicData::_ref_type& data, const DynamicDataJsonFormat format, @@ -67,23 +68,6 @@ ReturnCode_t json_serialize( return ret; } -ReturnCode_t idl_serialize( - const traits::ref_type& dynamic_type, - std::string& output) noexcept -{ - // Create a tree representation of the dynamic type - utilities::collections::TreeNode parent_type; - const auto ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); - - if (ret != RETCODE_OK) - { - return ret; - } - - // Serialize the tree to IDL - return dyn_type_tree_to_idl(parent_type, output); -} - } // namespace dds } // namespace fastdds } // namespace eprosima diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index ae46e939720..075309b11a0 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -68,10 +68,18 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/key_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/key_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_bounded_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_bounded_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/multi_array_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/multi_array_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/nested_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/nested_struct.idl @@ -80,6 +88,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/string_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/idls/string_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/union_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/idls/union_struct.idl diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index 4855aa82df7..6a5ec2f1070 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -13,6 +13,7 @@ // limitations under the License. #include +#include #include #include @@ -34,13 +35,6 @@ using namespace eprosima::fastdds::dds; class DynTypeIDLTests : public ::testing::TestWithParam { -public: - - void SetUp() - { - test::register_dynamic_types(); - } - protected: void get_dynamic_type( @@ -57,6 +51,32 @@ class DynTypeIDLTests : public ::testing::TestWithParam dyn_type = DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object( type_objs.complete_type_object)->build(); } + + std::string snake_to_camel( + const std::string& snake_case) + { + std::string camel_case; + bool to_upper = true; + + for (char ch : snake_case) + { + if (ch == '_') + { + to_upper = true; + } + else if (to_upper) + { + camel_case += std::toupper(ch); + to_upper = false; + } + else + { + camel_case += ch; + } + } + + return camel_case; + } }; /** @@ -71,6 +91,8 @@ TEST_P(DynTypeIDLTests, to_idl) { const std::string type = GetParam(); + test::register_type_object_representation(type); + // Read the IDL file as a string const auto file_name = std::string("types/idls/") + type + ".idl"; @@ -84,11 +106,11 @@ TEST_P(DynTypeIDLTests, to_idl) get_dynamic_type(type, dyn_type); // Serialize DynamicType to IDL - std::string idl_serialization; + std::stringstream idl_serialization; ASSERT_EQ(idl_serialize(dyn_type, idl_serialization), RETCODE_OK); // Compare IDLs - ASSERT_EQ(idl_file, idl_serialization); + ASSERT_EQ(idl_file, idl_serialization.str()); } INSTANTIATE_TEST_SUITE_P( diff --git a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp index cc784d24251..91aa7a99b9a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp @@ -62,15 +62,24 @@ #include "gen/key_struct/key_struct.hpp" #include "gen/key_struct/key_structPubSubTypes.hpp" +#include "gen/map_bounded_struct/map_bounded_struct.hpp" +#include "gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp" + #include "gen/map_struct/map_struct.hpp" #include "gen/map_struct/map_structPubSubTypes.hpp" +#include "gen/multi_array_struct/multi_array_struct.hpp" +#include "gen/multi_array_struct/multi_array_structPubSubTypes.hpp" + #include "gen/nested_struct/nested_struct.hpp" #include "gen/nested_struct/nested_structPubSubTypes.hpp" #include "gen/numeric_array/numeric_array.hpp" #include "gen/numeric_array/numeric_arrayPubSubTypes.hpp" +#include "gen/string_struct/string_struct.hpp" +#include "gen/string_struct/string_structPubSubTypes.hpp" + #include "gen/union_struct/union_struct.hpp" #include "gen/union_struct/union_structPubSubTypes.hpp" @@ -92,9 +101,12 @@ const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; const std::string HELLO_WORLD{"hello_world"}; const std::string INHERITANCE_STRUCT{"inheritance_struct"}; const std::string KEY_STRUCT{"key_struct"}; +const std::string MAP_BOUNDED_STRUCT{"map_bounded_struct"}; const std::string MAP_STRUCT{"map_struct"}; +const std::string MULTI_ARRAY_STRUCT{"multi_array_struct"}; const std::string NESTED_STRUCT{"nested_struct"}; const std::string NUMERIC_ARRAY{"numeric_array"}; +const std::string STRING_STRUCT{"string_struct"}; const std::string UNION_STRUCT{"union_struct"}; } // namespace SupportedTypes @@ -114,69 +126,129 @@ const std::vector supported_types = { SupportedTypes::HELLO_WORLD, SupportedTypes::INHERITANCE_STRUCT, SupportedTypes::KEY_STRUCT, + SupportedTypes::MAP_BOUNDED_STRUCT, SupportedTypes::MAP_STRUCT, + SupportedTypes::MULTI_ARRAY_STRUCT, SupportedTypes::NESTED_STRUCT, SupportedTypes::NUMERIC_ARRAY, + SupportedTypes::STRING_STRUCT, SupportedTypes::UNION_STRUCT }; -void register_dynamic_types() +void register_type_object_representation( + const std::string& type_name) { using namespace eprosima::fastdds::dds; - TypeSupport type_alias_struct(new alias_structPubSubType()); - type_alias_struct->register_type_object_representation(); - - TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); - type_arrays_and_sequences->register_type_object_representation(); - - TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); - type_basic_array_struct->register_type_object_representation(); - - TypeSupport type_basic_struct(new basic_structPubSubType()); - type_basic_struct->register_type_object_representation(); - - TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); - type_bitmask_struct->register_type_object_representation(); - - TypeSupport type_bitset_struct(new bitset_structPubSubType()); - type_bitset_struct->register_type_object_representation(); - - TypeSupport type_char_sequence(new char_sequencePubSubType()); - type_char_sequence->register_type_object_representation(); - - TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); - type_complex_nested_arrays->register_type_object_representation(); - - TypeSupport type_enum_struct(new enum_structPubSubType()); - type_enum_struct->register_type_object_representation(); - - TypeSupport type_extensibility_struct(new extensibility_structPubSubType()); - type_extensibility_struct->register_type_object_representation(); - - TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); - type_float_bounded_sequence->register_type_object_representation(); - - TypeSupport type_hello_world(new hello_worldPubSubType()); - type_hello_world->register_type_object_representation(); - - TypeSupport type_inheritance_struct(new inheritance_structPubSubType()); - type_inheritance_struct->register_type_object_representation(); - - TypeSupport type_key_struct(new key_structPubSubType()); - type_key_struct->register_type_object_representation(); - - TypeSupport type_map_struct(new map_structPubSubType()); - type_map_struct->register_type_object_representation(); - - TypeSupport type_nested_struct(new nested_structPubSubType()); - type_nested_struct->register_type_object_representation(); - - TypeSupport type_numeric_array(new numeric_arrayPubSubType()); - type_numeric_array->register_type_object_representation(); - - TypeSupport type_union_struct(new union_structPubSubType()); - type_union_struct->register_type_object_representation(); + if (type_name == SupportedTypes::ALIAS_STRUCT) + { + TypeSupport type_alias_struct(new alias_structPubSubType()); + type_alias_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::ARRAYS_AND_SEQUENCES) + { + TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); + type_arrays_and_sequences->register_type_object_representation(); + } + else if (type_name == SupportedTypes::BASIC_ARRAY_STRUCT) + { + TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); + type_basic_array_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::BASIC_STRUCT) + { + TypeSupport type_basic_struct(new basic_structPubSubType()); + type_basic_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::BITMASK_STRUCT) + { + TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); + type_bitmask_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::BITSET_STRUCT) + { + TypeSupport type_bitset_struct(new bitset_structPubSubType()); + type_bitset_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::CHAR_SEQUENCE) + { + TypeSupport type_char_sequence(new char_sequencePubSubType()); + type_char_sequence->register_type_object_representation(); + } + else if (type_name == SupportedTypes::COMPLEX_NESTED_ARRAYS) + { + TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); + type_complex_nested_arrays->register_type_object_representation(); + } + else if (type_name == SupportedTypes::ENUM_STRUCT) + { + TypeSupport type_enum_struct(new enum_structPubSubType()); + type_enum_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::EXTENSIBILITY_STRUCT) + { + TypeSupport type_extensibility_struct(new extensibility_structPubSubType()); + type_extensibility_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::FLOAT_BOUNDED_SEQUENCE) + { + TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); + type_float_bounded_sequence->register_type_object_representation(); + } + else if (type_name == SupportedTypes::HELLO_WORLD) + { + TypeSupport type_hello_world(new hello_worldPubSubType()); + type_hello_world->register_type_object_representation(); + } + else if (type_name == SupportedTypes::INHERITANCE_STRUCT) + { + TypeSupport type_inheritance_struct(new inheritance_structPubSubType()); + type_inheritance_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::KEY_STRUCT) + { + TypeSupport type_key_struct(new key_structPubSubType()); + type_key_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::MAP_BOUNDED_STRUCT) + { + TypeSupport type_map_bounded_struct(new map_bounded_structPubSubType()); + type_map_bounded_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::MAP_STRUCT) + { + TypeSupport type_map_struct(new map_structPubSubType()); + type_map_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::MULTI_ARRAY_STRUCT) + { + TypeSupport type_multi_array_struct(new multi_array_structPubSubType()); + type_multi_array_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::NESTED_STRUCT) + { + TypeSupport type_nested_struct(new nested_structPubSubType()); + type_nested_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::NUMERIC_ARRAY) + { + TypeSupport type_numeric_array(new numeric_arrayPubSubType()); + type_numeric_array->register_type_object_representation(); + } + else if (type_name == SupportedTypes::STRING_STRUCT) + { + TypeSupport type_string_struct(new string_structPubSubType()); + type_string_struct->register_type_object_representation(); + } + else if (type_name == SupportedTypes::UNION_STRUCT) + { + TypeSupport type_union_struct(new union_structPubSubType()); + type_union_struct->register_type_object_representation(); + } + else + { + ASSERT_FALSE(true) << "Type not supported"; + } } } /* namespace test */ diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp new file mode 100644 index 00000000000..0cac9acbdc1 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp @@ -0,0 +1,191 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_HPP +#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_HPP + +#include +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(MAP_BOUNDED_STRUCT_SOURCE) +#define MAP_BOUNDED_STRUCT_DllAPI __declspec( dllexport ) +#else +#define MAP_BOUNDED_STRUCT_DllAPI __declspec( dllimport ) +#endif // MAP_BOUNDED_STRUCT_SOURCE +#else +#define MAP_BOUNDED_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define MAP_BOUNDED_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure map_bounded_struct defined by the user in the IDL file. + * @ingroup map_bounded_struct + */ +class map_bounded_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport map_bounded_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~map_bounded_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object map_bounded_struct that will be copied. + */ + eProsima_user_DllExport map_bounded_struct( + const map_bounded_struct& x) + { + m_my_map = x.m_my_map; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object map_bounded_struct that will be copied. + */ + eProsima_user_DllExport map_bounded_struct( + map_bounded_struct&& x) noexcept + { + m_my_map = std::move(x.m_my_map); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object map_bounded_struct that will be copied. + */ + eProsima_user_DllExport map_bounded_struct& operator =( + const map_bounded_struct& x) + { + + m_my_map = x.m_my_map; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object map_bounded_struct that will be copied. + */ + eProsima_user_DllExport map_bounded_struct& operator =( + map_bounded_struct&& x) noexcept + { + + m_my_map = std::move(x.m_my_map); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x map_bounded_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const map_bounded_struct& x) const + { + return (m_my_map == x.m_my_map); + } + + /*! + * @brief Comparison operator. + * @param x map_bounded_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const map_bounded_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_map + * @param _my_map New value to be copied in member my_map + */ + eProsima_user_DllExport void my_map( + const std::map& _my_map) + { + m_my_map = _my_map; + } + + /*! + * @brief This function moves the value in member my_map + * @param _my_map New value to be moved in member my_map + */ + eProsima_user_DllExport void my_map( + std::map&& _my_map) + { + m_my_map = std::move(_my_map); + } + + /*! + * @brief This function returns a constant reference to member my_map + * @return Constant reference to member my_map + */ + eProsima_user_DllExport const std::map& my_map() const + { + return m_my_map; + } + + /*! + * @brief This function returns a reference to member my_map + * @return Reference to member my_map + */ + eProsima_user_DllExport std::map& my_map() + { + return m_my_map; + } + + + +private: + + std::map m_my_map; + +}; + +#endif // _FAST_DDS_GENERATED_MAP_BOUNDED_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp new file mode 100644 index 00000000000..44968846043 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP + +#include "map_bounded_struct.hpp" + +constexpr uint32_t map_bounded_struct_max_cdr_typesize {2645UL}; +constexpr uint32_t map_bounded_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const map_bounded_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp new file mode 100644 index 00000000000..d397554fb23 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp @@ -0,0 +1,118 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP + +#include "map_bounded_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const map_bounded_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_map(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const map_bounded_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_map() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + map_bounded_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_map(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const map_bounded_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx new file mode 100644 index 00000000000..920d0c0b51e --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "map_bounded_structPubSubTypes.hpp" + +#include +#include + +#include "map_bounded_structCdrAux.hpp" +#include "map_bounded_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +map_bounded_structPubSubType::map_bounded_structPubSubType() +{ + setName("map_bounded_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(map_bounded_struct::getMaxCdrSerializedSize()); +#else + map_bounded_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = map_bounded_struct_max_key_cdr_typesize > 16 ? map_bounded_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +map_bounded_structPubSubType::~map_bounded_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool map_bounded_structPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const map_bounded_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool map_bounded_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + map_bounded_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function map_bounded_structPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* map_bounded_structPubSubType::createData() +{ + return reinterpret_cast(new map_bounded_struct()); +} + +void map_bounded_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool map_bounded_structPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const map_bounded_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + map_bounded_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || map_bounded_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void map_bounded_structPubSubType::register_type_object_representation() +{ + register_map_bounded_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "map_bounded_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp new file mode 100644 index 00000000000..fce53a4d2c8 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structPubSubTypes.hpp + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP + +#include +#include +#include +#include +#include + +#include "map_bounded_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated map_bounded_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type map_bounded_struct defined by the user in the IDL file. + * @ingroup map_bounded_struct + */ +class map_bounded_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef map_bounded_struct type; + + eProsima_user_DllExport map_bounded_structPubSubType(); + + eProsima_user_DllExport ~map_bounded_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..32db4e123f1 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx @@ -0,0 +1,167 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "map_bounded_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "map_bounded_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_map_bounded_struct_type_identifier( + TypeIdentifierPair& type_ids_map_bounded_struct) +{ + + ReturnCode_t return_code_map_bounded_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_map_bounded_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "map_bounded_struct", type_ids_map_bounded_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_map_bounded_struct) + { + StructTypeFlag struct_flags_map_bounded_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_map_bounded_struct = "map_bounded_struct"; + eprosima::fastcdr::optional type_ann_builtin_map_bounded_struct; + eprosima::fastcdr::optional ann_custom_map_bounded_struct; + CompleteTypeDetail detail_map_bounded_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_map_bounded_struct, ann_custom_map_bounded_struct, type_name_map_bounded_struct.to_string()); + CompleteStructHeader header_map_bounded_struct; + header_map_bounded_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_map_bounded_struct); + CompleteStructMemberSeq member_seq_map_bounded_struct; + { + TypeIdentifierPair type_ids_my_map; + ReturnCode_t return_code_my_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_map_anonymous_string_unbounded_bool_10", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Map element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_bool_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec))}; + if (!element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_10 inconsistent element TypeIdentifier."); + return; + } + return_code_my_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + bool key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec {false}; + TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_bool_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec))}; + if (!key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_10 inconsistent key TypeIdentifier."); + return; + } + EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10 = EK_BOTH; + if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d()) || + (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->seq_sdefn().header().equiv_kind()) || + (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->seq_ldefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->array_sdefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->array_ldefn().header().equiv_kind()) || + (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_sdefn().header().equiv_kind())) || + (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_ldefn().header().equiv_kind()))) + { + equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10 = EK_COMPLETE; + } + CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_bool_10 = 0; + CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_bool_10 = 0; + PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_bool_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10, element_flags_anonymous_map_anonymous_string_unbounded_bool_10); + { + SBound bound = static_cast(10); + PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_bool_10, bound, + eprosima::fastcdr::external(element_identifier_anonymous_map_anonymous_string_unbounded_bool_10), key_flags_anonymous_map_anonymous_string_unbounded_bool_10, + eprosima::fastcdr::external(key_identifier_anonymous_map_anonymous_string_unbounded_bool_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_bool_10", type_ids_my_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_bool_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_map = 0x00000000; + bool common_my_map_ec {false}; + CommonStructMember common_my_map {TypeObjectUtils::build_common_struct_member(member_id_my_map, member_flags_my_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, common_my_map_ec))}; + if (!common_my_map_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_map member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_map = "my_map"; + eprosima::fastcdr::optional member_ann_builtin_my_map; + ann_custom_map_bounded_struct.reset(); + CompleteMemberDetail detail_my_map = TypeObjectUtils::build_complete_member_detail(name_my_map, member_ann_builtin_my_map, ann_custom_map_bounded_struct); + CompleteStructMember member_my_map = TypeObjectUtils::build_complete_struct_member(common_my_map, detail_my_map); + TypeObjectUtils::add_complete_struct_member(member_seq_map_bounded_struct, member_my_map); + } + CompleteStructType struct_type_map_bounded_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_map_bounded_struct, header_map_bounded_struct, member_seq_map_bounded_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_map_bounded_struct, type_name_map_bounded_struct.to_string(), type_ids_map_bounded_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "map_bounded_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..e3588968c1a --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file map_bounded_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register map_bounded_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_map_bounded_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp index cb2ed629ccb..4336aaa055f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp @@ -52,6 +52,129 @@ #define MAP_STRUCT_DllAPI #endif // _WIN32 +/*! + * @brief This class represents the structure ValueStruct defined by the user in the IDL file. + * @ingroup map_struct + */ +class ValueStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ValueStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ValueStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ValueStruct that will be copied. + */ + eProsima_user_DllExport ValueStruct( + const ValueStruct& x) + { + m_value = x.m_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ValueStruct that will be copied. + */ + eProsima_user_DllExport ValueStruct( + ValueStruct&& x) noexcept + { + m_value = x.m_value; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ValueStruct that will be copied. + */ + eProsima_user_DllExport ValueStruct& operator =( + const ValueStruct& x) + { + + m_value = x.m_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ValueStruct that will be copied. + */ + eProsima_user_DllExport ValueStruct& operator =( + ValueStruct&& x) noexcept + { + + m_value = x.m_value; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ValueStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ValueStruct& x) const + { + return (m_value == x.m_value); + } + + /*! + * @brief Comparison operator. + * @param x ValueStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ValueStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member value + * @param _value New value for member value + */ + eProsima_user_DllExport void value( + bool _value) + { + m_value = _value; + } + + /*! + * @brief This function returns the value of member value + * @return Value of member value + */ + eProsima_user_DllExport bool value() const + { + return m_value; + } + + /*! + * @brief This function returns a reference to member value + * @return Reference to member value + */ + eProsima_user_DllExport bool& value() + { + return m_value; + } + + + +private: + + bool m_value{false}; + +}; /*! * @brief This class represents the structure map_struct defined by the user in the IDL file. * @ingroup map_struct @@ -81,7 +204,9 @@ class map_struct eProsima_user_DllExport map_struct( const map_struct& x) { - m_my_map = x.m_my_map; + m_my_basic_map = x.m_my_basic_map; + + m_my_complex_map = x.m_my_complex_map; } @@ -92,7 +217,8 @@ class map_struct eProsima_user_DllExport map_struct( map_struct&& x) noexcept { - m_my_map = std::move(x.m_my_map); + m_my_basic_map = std::move(x.m_my_basic_map); + m_my_complex_map = std::move(x.m_my_complex_map); } /*! @@ -103,7 +229,9 @@ class map_struct const map_struct& x) { - m_my_map = x.m_my_map; + m_my_basic_map = x.m_my_basic_map; + + m_my_complex_map = x.m_my_complex_map; return *this; } @@ -116,7 +244,8 @@ class map_struct map_struct&& x) noexcept { - m_my_map = std::move(x.m_my_map); + m_my_basic_map = std::move(x.m_my_basic_map); + m_my_complex_map = std::move(x.m_my_complex_map); return *this; } @@ -127,7 +256,8 @@ class map_struct eProsima_user_DllExport bool operator ==( const map_struct& x) const { - return (m_my_map == x.m_my_map); + return (m_my_basic_map == x.m_my_basic_map && + m_my_complex_map == x.m_my_complex_map); } /*! @@ -141,48 +271,88 @@ class map_struct } /*! - * @brief This function copies the value in member my_map - * @param _my_map New value to be copied in member my_map + * @brief This function copies the value in member my_basic_map + * @param _my_basic_map New value to be copied in member my_basic_map + */ + eProsima_user_DllExport void my_basic_map( + const std::map& _my_basic_map) + { + m_my_basic_map = _my_basic_map; + } + + /*! + * @brief This function moves the value in member my_basic_map + * @param _my_basic_map New value to be moved in member my_basic_map + */ + eProsima_user_DllExport void my_basic_map( + std::map&& _my_basic_map) + { + m_my_basic_map = std::move(_my_basic_map); + } + + /*! + * @brief This function returns a constant reference to member my_basic_map + * @return Constant reference to member my_basic_map + */ + eProsima_user_DllExport const std::map& my_basic_map() const + { + return m_my_basic_map; + } + + /*! + * @brief This function returns a reference to member my_basic_map + * @return Reference to member my_basic_map + */ + eProsima_user_DllExport std::map& my_basic_map() + { + return m_my_basic_map; + } + + + /*! + * @brief This function copies the value in member my_complex_map + * @param _my_complex_map New value to be copied in member my_complex_map */ - eProsima_user_DllExport void my_map( - const std::map& _my_map) + eProsima_user_DllExport void my_complex_map( + const std::map& _my_complex_map) { - m_my_map = _my_map; + m_my_complex_map = _my_complex_map; } /*! - * @brief This function moves the value in member my_map - * @param _my_map New value to be moved in member my_map + * @brief This function moves the value in member my_complex_map + * @param _my_complex_map New value to be moved in member my_complex_map */ - eProsima_user_DllExport void my_map( - std::map&& _my_map) + eProsima_user_DllExport void my_complex_map( + std::map&& _my_complex_map) { - m_my_map = std::move(_my_map); + m_my_complex_map = std::move(_my_complex_map); } /*! - * @brief This function returns a constant reference to member my_map - * @return Constant reference to member my_map + * @brief This function returns a constant reference to member my_complex_map + * @return Constant reference to member my_complex_map */ - eProsima_user_DllExport const std::map& my_map() const + eProsima_user_DllExport const std::map& my_complex_map() const { - return m_my_map; + return m_my_complex_map; } /*! - * @brief This function returns a reference to member my_map - * @return Reference to member my_map + * @brief This function returns a reference to member my_complex_map + * @return Reference to member my_complex_map */ - eProsima_user_DllExport std::map& my_map() + eProsima_user_DllExport std::map& my_complex_map() { - return m_my_map; + return m_my_complex_map; } private: - std::map m_my_map; + std::map m_my_basic_map; + std::map m_my_complex_map; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp index bb78ac3b1e6..120daa8a2df 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp @@ -24,9 +24,12 @@ #include "map_struct.hpp" -constexpr uint32_t map_struct_max_cdr_typesize {8UL}; +constexpr uint32_t map_struct_max_cdr_typesize {16UL}; constexpr uint32_t map_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t ValueStruct_max_cdr_typesize {5UL}; +constexpr uint32_t ValueStruct_max_key_cdr_typesize {0UL}; + namespace eprosima { namespace fastcdr { @@ -34,6 +37,10 @@ namespace fastcdr { class Cdr; class CdrSizeCalculator; +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ValueStruct& data); + eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, const map_struct& data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp index 2fc10980476..4df3302bc02 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp @@ -34,6 +34,82 @@ using namespace eprosima::fastcdr::exception; namespace eprosima { namespace fastcdr { +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ValueStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.value(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ValueStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.value() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + ValueStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.value(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ValueStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, @@ -51,7 +127,10 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.my_map(), current_alignment); + data.my_basic_map(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_complex_map(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -71,7 +150,8 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.my_map() + << eprosima::fastcdr::MemberId(0) << data.my_basic_map() + << eprosima::fastcdr::MemberId(1) << data.my_complex_map() ; scdr.end_serialize_type(current_state); } @@ -90,7 +170,11 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.my_map(); + dcdr >> data.my_basic_map(); + break; + + case 1: + dcdr >> data.my_complex_map(); break; default: diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx index 4b3396a9db9..d82e97d64f7 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx @@ -31,6 +31,199 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; +ValueStructPubSubType::ValueStructPubSubType() +{ + setName("ValueStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(ValueStruct::getMaxCdrSerializedSize()); +#else + ValueStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = ValueStruct_max_key_cdr_typesize > 16 ? ValueStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +ValueStructPubSubType::~ValueStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool ValueStructPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const ValueStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool ValueStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + ValueStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function ValueStructPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* ValueStructPubSubType::createData() +{ + return reinterpret_cast(new ValueStruct()); +} + +void ValueStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool ValueStructPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const ValueStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + ValueStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || ValueStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void ValueStructPubSubType::register_type_object_representation() +{ + register_ValueStruct_type_identifier(type_identifiers_); +} + map_structPubSubType::map_structPubSubType() { setName("map_struct"); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp index d9edf34089d..dce42dd8fd2 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp @@ -38,6 +38,97 @@ #endif // GEN_API_VER +/*! + * @brief This class represents the TopicDataType of the type ValueStruct defined by the user in the IDL file. + * @ingroup map_struct + */ +class ValueStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef ValueStruct type; + + eProsima_user_DllExport ValueStructPubSubType(); + + eProsima_user_DllExport ~ValueStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + /*! * @brief This class represents the TopicDataType of the type map_struct defined by the user in the IDL file. * @ingroup map_struct diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx index e4d4e981bc3..7fee45dd119 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx @@ -38,6 +38,65 @@ using namespace eprosima::fastdds::dds::xtypes; +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ValueStruct_type_identifier( + TypeIdentifierPair& type_ids_ValueStruct) +{ + + ReturnCode_t return_code_ValueStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ValueStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ValueStruct", type_ids_ValueStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ValueStruct) + { + StructTypeFlag struct_flags_ValueStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ValueStruct = "ValueStruct"; + eprosima::fastcdr::optional type_ann_builtin_ValueStruct; + eprosima::fastcdr::optional ann_custom_ValueStruct; + CompleteTypeDetail detail_ValueStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ValueStruct, ann_custom_ValueStruct, type_name_ValueStruct.to_string()); + CompleteStructHeader header_ValueStruct; + header_ValueStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ValueStruct); + CompleteStructMemberSeq member_seq_ValueStruct; + { + TypeIdentifierPair type_ids_value; + ReturnCode_t return_code_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_value = 0x00000000; + bool common_value_ec {false}; + CommonStructMember common_value {TypeObjectUtils::build_common_struct_member(member_id_value, member_flags_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_value, common_value_ec))}; + if (!common_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure value member TypeIdentifier inconsistent."); + return; + } + MemberName name_value = "value"; + eprosima::fastcdr::optional member_ann_builtin_value; + ann_custom_ValueStruct.reset(); + CompleteMemberDetail detail_value = TypeObjectUtils::build_complete_member_detail(name_value, member_ann_builtin_value, ann_custom_ValueStruct); + CompleteStructMember member_value = TypeObjectUtils::build_complete_struct_member(common_value, detail_value); + TypeObjectUtils::add_complete_struct_member(member_seq_ValueStruct, member_value); + } + CompleteStructType struct_type_ValueStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ValueStruct, header_ValueStruct, member_seq_ValueStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ValueStruct, type_name_ValueStruct.to_string(), type_ids_ValueStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ValueStruct already registered in TypeObjectRegistry for a different type."); + } + } +} // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method void register_map_struct_type_identifier( TypeIdentifierPair& type_ids_map_struct) @@ -59,44 +118,44 @@ void register_map_struct_type_identifier( header_map_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_map_struct); CompleteStructMemberSeq member_seq_map_struct; { - TypeIdentifierPair type_ids_my_map; - ReturnCode_t return_code_my_map {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_map = + TypeIdentifierPair type_ids_my_basic_map; + ReturnCode_t return_code_my_basic_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_basic_map = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_map); + "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_basic_map); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_map) { - return_code_my_map = + return_code_my_basic_map = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_bool", type_ids_my_map); + "_bool", type_ids_my_basic_map); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_map) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Map element TypeIdentifier unknown to TypeObjectRegistry."); return; } bool element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec {false}; - TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; + TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_map, element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; if (!element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "anonymous_map_anonymous_string_unbounded_bool_unbounded inconsistent element TypeIdentifier."); return; } - return_code_my_map = + return_code_my_basic_map = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_string_unbounded", type_ids_my_map); + "anonymous_string_unbounded", type_ids_my_basic_map); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_map) { { SBound bound = 0; StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, - "anonymous_string_unbounded", type_ids_my_map)) + "anonymous_string_unbounded", type_ids_my_basic_map)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); @@ -104,7 +163,7 @@ void register_map_struct_type_identifier( } } bool key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec {false}; - TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; + TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_map, key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec))}; if (!key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded_ec) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, @@ -131,29 +190,124 @@ void register_map_struct_type_identifier( eprosima::fastcdr::external(element_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_bool_unbounded, eprosima::fastcdr::external(key_identifier_anonymous_map_anonymous_string_unbounded_bool_unbounded)); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_map)) + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_bool_unbounded", type_ids_my_basic_map)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "anonymous_map_anonymous_string_unbounded_bool_unbounded already registered in TypeObjectRegistry for a different type."); } } } - StructMemberFlag member_flags_my_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_basic_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_basic_map = 0x00000000; + bool common_my_basic_map_ec {false}; + CommonStructMember common_my_basic_map {TypeObjectUtils::build_common_struct_member(member_id_my_basic_map, member_flags_my_basic_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_map, common_my_basic_map_ec))}; + if (!common_my_basic_map_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_map member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_basic_map = "my_basic_map"; + eprosima::fastcdr::optional member_ann_builtin_my_basic_map; + ann_custom_map_struct.reset(); + CompleteMemberDetail detail_my_basic_map = TypeObjectUtils::build_complete_member_detail(name_my_basic_map, member_ann_builtin_my_basic_map, ann_custom_map_struct); + CompleteStructMember member_my_basic_map = TypeObjectUtils::build_complete_struct_member(common_my_basic_map, detail_my_basic_map); + TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_basic_map); + } + { + TypeIdentifierPair type_ids_my_complex_map; + ReturnCode_t return_code_my_complex_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded", type_ids_my_complex_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_map) + { + return_code_my_complex_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ValueStruct", type_ids_my_complex_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_map) + { + ::register_ValueStruct_type_identifier(type_ids_my_complex_map); + } + bool element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_map, element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec))}; + if (!element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded inconsistent element TypeIdentifier."); + return; + } + return_code_my_complex_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_complex_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_map) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_complex_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + bool key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec {false}; + TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_map, key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec))}; + if (!key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded inconsistent key TypeIdentifier."); + return; + } + EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded = EK_BOTH; + if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d()) || + (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->seq_sdefn().header().equiv_kind()) || + (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->seq_ldefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->array_sdefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->array_ldefn().header().equiv_kind()) || + (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->map_sdefn().header().equiv_kind())) || + (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded->map_ldefn().header().equiv_kind()))) + { + equiv_kind_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded = EK_COMPLETE; + } + CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded = 0; + CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded = 0; + PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded); + { + SBound bound = 0; + PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded, + eprosima::fastcdr::external(key_identifier_anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded", type_ids_my_complex_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_anonymous_string_unbounded_ValueStruct_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_complex_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_map = 0x00000000; - bool common_my_map_ec {false}; - CommonStructMember common_my_map {TypeObjectUtils::build_common_struct_member(member_id_my_map, member_flags_my_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, common_my_map_ec))}; - if (!common_my_map_ec) + MemberId member_id_my_complex_map = 0x00000001; + bool common_my_complex_map_ec {false}; + CommonStructMember common_my_complex_map {TypeObjectUtils::build_common_struct_member(member_id_my_complex_map, member_flags_my_complex_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_map, common_my_complex_map_ec))}; + if (!common_my_complex_map_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_map member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_map member TypeIdentifier inconsistent."); return; } - MemberName name_my_map = "my_map"; - eprosima::fastcdr::optional member_ann_builtin_my_map; + MemberName name_my_complex_map = "my_complex_map"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_map; ann_custom_map_struct.reset(); - CompleteMemberDetail detail_my_map = TypeObjectUtils::build_complete_member_detail(name_my_map, member_ann_builtin_my_map, ann_custom_map_struct); - CompleteStructMember member_my_map = TypeObjectUtils::build_complete_struct_member(common_my_map, detail_my_map); - TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_map); + CompleteMemberDetail detail_my_complex_map = TypeObjectUtils::build_complete_member_detail(name_my_complex_map, member_ann_builtin_my_complex_map, ann_custom_map_struct); + CompleteStructMember member_my_complex_map = TypeObjectUtils::build_complete_struct_member(common_my_complex_map, detail_my_complex_map); + TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_complex_map); } CompleteStructType struct_type_map_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_map_struct, header_map_struct, member_seq_map_struct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp index 6a1a1e1df1a..4d40bbec1c7 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp @@ -37,6 +37,18 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC +/** + * @brief Register ValueStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ValueStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** * @brief Register map_struct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp new file mode 100644 index 00000000000..ca019fc28fa --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp @@ -0,0 +1,386 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_HPP +#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_HPP + +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(MULTI_ARRAY_STRUCT_SOURCE) +#define MULTI_ARRAY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define MULTI_ARRAY_STRUCT_DllAPI __declspec( dllimport ) +#endif // MULTI_ARRAY_STRUCT_SOURCE +#else +#define MULTI_ARRAY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define MULTI_ARRAY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure ColorAmount defined by the user in the IDL file. + * @ingroup multi_array_struct + */ +class ColorAmount +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ColorAmount() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ColorAmount() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ColorAmount that will be copied. + */ + eProsima_user_DllExport ColorAmount( + const ColorAmount& x) + { + m_red = x.m_red; + + m_green = x.m_green; + + m_blue = x.m_blue; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ColorAmount that will be copied. + */ + eProsima_user_DllExport ColorAmount( + ColorAmount&& x) noexcept + { + m_red = x.m_red; + m_green = x.m_green; + m_blue = x.m_blue; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ColorAmount that will be copied. + */ + eProsima_user_DllExport ColorAmount& operator =( + const ColorAmount& x) + { + + m_red = x.m_red; + + m_green = x.m_green; + + m_blue = x.m_blue; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ColorAmount that will be copied. + */ + eProsima_user_DllExport ColorAmount& operator =( + ColorAmount&& x) noexcept + { + + m_red = x.m_red; + m_green = x.m_green; + m_blue = x.m_blue; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ColorAmount object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ColorAmount& x) const + { + return (m_red == x.m_red && + m_green == x.m_green && + m_blue == x.m_blue); + } + + /*! + * @brief Comparison operator. + * @param x ColorAmount object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ColorAmount& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member red + * @param _red New value for member red + */ + eProsima_user_DllExport void red( + int32_t _red) + { + m_red = _red; + } + + /*! + * @brief This function returns the value of member red + * @return Value of member red + */ + eProsima_user_DllExport int32_t red() const + { + return m_red; + } + + /*! + * @brief This function returns a reference to member red + * @return Reference to member red + */ + eProsima_user_DllExport int32_t& red() + { + return m_red; + } + + + /*! + * @brief This function sets a value in member green + * @param _green New value for member green + */ + eProsima_user_DllExport void green( + int32_t _green) + { + m_green = _green; + } + + /*! + * @brief This function returns the value of member green + * @return Value of member green + */ + eProsima_user_DllExport int32_t green() const + { + return m_green; + } + + /*! + * @brief This function returns a reference to member green + * @return Reference to member green + */ + eProsima_user_DllExport int32_t& green() + { + return m_green; + } + + + /*! + * @brief This function sets a value in member blue + * @param _blue New value for member blue + */ + eProsima_user_DllExport void blue( + int32_t _blue) + { + m_blue = _blue; + } + + /*! + * @brief This function returns the value of member blue + * @return Value of member blue + */ + eProsima_user_DllExport int32_t blue() const + { + return m_blue; + } + + /*! + * @brief This function returns a reference to member blue + * @return Reference to member blue + */ + eProsima_user_DllExport int32_t& blue() + { + return m_blue; + } + + + +private: + + int32_t m_red{0}; + int32_t m_green{0}; + int32_t m_blue{0}; + +}; +/*! + * @brief This class represents the structure multi_array_struct defined by the user in the IDL file. + * @ingroup multi_array_struct + */ +class multi_array_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport multi_array_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~multi_array_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object multi_array_struct that will be copied. + */ + eProsima_user_DllExport multi_array_struct( + const multi_array_struct& x) + { + m_colors = x.m_colors; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object multi_array_struct that will be copied. + */ + eProsima_user_DllExport multi_array_struct( + multi_array_struct&& x) noexcept + { + m_colors = std::move(x.m_colors); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object multi_array_struct that will be copied. + */ + eProsima_user_DllExport multi_array_struct& operator =( + const multi_array_struct& x) + { + + m_colors = x.m_colors; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object multi_array_struct that will be copied. + */ + eProsima_user_DllExport multi_array_struct& operator =( + multi_array_struct&& x) noexcept + { + + m_colors = std::move(x.m_colors); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x multi_array_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const multi_array_struct& x) const + { + return (m_colors == x.m_colors); + } + + /*! + * @brief Comparison operator. + * @param x multi_array_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const multi_array_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member colors + * @param _colors New value to be copied in member colors + */ + eProsima_user_DllExport void colors( + const std::array, 5>, 5>& _colors) + { + m_colors = _colors; + } + + /*! + * @brief This function moves the value in member colors + * @param _colors New value to be moved in member colors + */ + eProsima_user_DllExport void colors( + std::array, 5>, 5>&& _colors) + { + m_colors = std::move(_colors); + } + + /*! + * @brief This function returns a constant reference to member colors + * @return Constant reference to member colors + */ + eProsima_user_DllExport const std::array, 5>, 5>& colors() const + { + return m_colors; + } + + /*! + * @brief This function returns a reference to member colors + * @return Reference to member colors + */ + eProsima_user_DllExport std::array, 5>, 5>& colors() + { + return m_colors; + } + + + +private: + + std::array, 5>, 5> m_colors; + +}; + +#endif // _FAST_DDS_GENERATED_MULTI_ARRAY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp new file mode 100644 index 00000000000..ed9892d62b3 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp @@ -0,0 +1,53 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP + +#include "multi_array_struct.hpp" + +constexpr uint32_t ColorAmount_max_cdr_typesize {16UL}; +constexpr uint32_t ColorAmount_max_key_cdr_typesize {0UL}; + +constexpr uint32_t multi_array_struct_max_cdr_typesize {2008UL}; +constexpr uint32_t multi_array_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ColorAmount& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const multi_array_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp new file mode 100644 index 00000000000..48b72fb8b7c --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp @@ -0,0 +1,210 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP + +#include "multi_array_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ColorAmount& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.red(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.green(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.blue(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ColorAmount& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.red() + << eprosima::fastcdr::MemberId(1) << data.green() + << eprosima::fastcdr::MemberId(2) << data.blue() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + ColorAmount& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.red(); + break; + + case 1: + dcdr >> data.green(); + break; + + case 2: + dcdr >> data.blue(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ColorAmount& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const multi_array_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.colors(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const multi_array_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.colors() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + multi_array_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.colors(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const multi_array_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx new file mode 100644 index 00000000000..94c1c990483 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx @@ -0,0 +1,422 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "multi_array_structPubSubTypes.hpp" + +#include +#include + +#include "multi_array_structCdrAux.hpp" +#include "multi_array_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +ColorAmountPubSubType::ColorAmountPubSubType() +{ + setName("ColorAmount"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(ColorAmount::getMaxCdrSerializedSize()); +#else + ColorAmount_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = ColorAmount_max_key_cdr_typesize > 16 ? ColorAmount_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +ColorAmountPubSubType::~ColorAmountPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool ColorAmountPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const ColorAmount* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool ColorAmountPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + ColorAmount* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function ColorAmountPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* ColorAmountPubSubType::createData() +{ + return reinterpret_cast(new ColorAmount()); +} + +void ColorAmountPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool ColorAmountPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const ColorAmount* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + ColorAmount_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || ColorAmount_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void ColorAmountPubSubType::register_type_object_representation() +{ + register_ColorAmount_type_identifier(type_identifiers_); +} + +multi_array_structPubSubType::multi_array_structPubSubType() +{ + setName("multi_array_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(multi_array_struct::getMaxCdrSerializedSize()); +#else + multi_array_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = multi_array_struct_max_key_cdr_typesize > 16 ? multi_array_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +multi_array_structPubSubType::~multi_array_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool multi_array_structPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const multi_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool multi_array_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + multi_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function multi_array_structPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* multi_array_structPubSubType::createData() +{ + return reinterpret_cast(new multi_array_struct()); +} + +void multi_array_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool multi_array_structPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const multi_array_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + multi_array_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || multi_array_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void multi_array_structPubSubType::register_type_object_representation() +{ + register_multi_array_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "multi_array_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp new file mode 100644 index 00000000000..0adcfa1fa6a --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp @@ -0,0 +1,224 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structPubSubTypes.hpp + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP + +#include +#include +#include +#include +#include + +#include "multi_array_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated multi_array_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type ColorAmount defined by the user in the IDL file. + * @ingroup multi_array_struct + */ +class ColorAmountPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef ColorAmount type; + + eProsima_user_DllExport ColorAmountPubSubType(); + + eProsima_user_DllExport ~ColorAmountPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type multi_array_struct defined by the user in the IDL file. + * @ingroup multi_array_struct + */ +class multi_array_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef multi_array_struct type; + + eProsima_user_DllExport multi_array_structPubSubType(); + + eProsima_user_DllExport ~multi_array_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..0be126797bb --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx @@ -0,0 +1,255 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "multi_array_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "multi_array_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ColorAmount_type_identifier( + TypeIdentifierPair& type_ids_ColorAmount) +{ + + ReturnCode_t return_code_ColorAmount {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ColorAmount = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorAmount", type_ids_ColorAmount); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ColorAmount) + { + StructTypeFlag struct_flags_ColorAmount = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ColorAmount = "ColorAmount"; + eprosima::fastcdr::optional type_ann_builtin_ColorAmount; + eprosima::fastcdr::optional ann_custom_ColorAmount; + CompleteTypeDetail detail_ColorAmount = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ColorAmount, ann_custom_ColorAmount, type_name_ColorAmount.to_string()); + CompleteStructHeader header_ColorAmount; + header_ColorAmount = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ColorAmount); + CompleteStructMemberSeq member_seq_ColorAmount; + { + TypeIdentifierPair type_ids_red; + ReturnCode_t return_code_red {eprosima::fastdds::dds::RETCODE_OK}; + return_code_red = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_red); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_red) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "red Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_red = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_red = 0x00000000; + bool common_red_ec {false}; + CommonStructMember common_red {TypeObjectUtils::build_common_struct_member(member_id_red, member_flags_red, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_red, common_red_ec))}; + if (!common_red_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure red member TypeIdentifier inconsistent."); + return; + } + MemberName name_red = "red"; + eprosima::fastcdr::optional member_ann_builtin_red; + ann_custom_ColorAmount.reset(); + CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_ColorAmount); + CompleteStructMember member_red = TypeObjectUtils::build_complete_struct_member(common_red, detail_red); + TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_red); + } + { + TypeIdentifierPair type_ids_green; + ReturnCode_t return_code_green {eprosima::fastdds::dds::RETCODE_OK}; + return_code_green = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_green); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_green) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "green Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_green = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_green = 0x00000001; + bool common_green_ec {false}; + CommonStructMember common_green {TypeObjectUtils::build_common_struct_member(member_id_green, member_flags_green, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_green, common_green_ec))}; + if (!common_green_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure green member TypeIdentifier inconsistent."); + return; + } + MemberName name_green = "green"; + eprosima::fastcdr::optional member_ann_builtin_green; + ann_custom_ColorAmount.reset(); + CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_ColorAmount); + CompleteStructMember member_green = TypeObjectUtils::build_complete_struct_member(common_green, detail_green); + TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_green); + } + { + TypeIdentifierPair type_ids_blue; + ReturnCode_t return_code_blue {eprosima::fastdds::dds::RETCODE_OK}; + return_code_blue = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_blue); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_blue) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "blue Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_blue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_blue = 0x00000002; + bool common_blue_ec {false}; + CommonStructMember common_blue {TypeObjectUtils::build_common_struct_member(member_id_blue, member_flags_blue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_blue, common_blue_ec))}; + if (!common_blue_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure blue member TypeIdentifier inconsistent."); + return; + } + MemberName name_blue = "blue"; + eprosima::fastcdr::optional member_ann_builtin_blue; + ann_custom_ColorAmount.reset(); + CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_ColorAmount); + CompleteStructMember member_blue = TypeObjectUtils::build_complete_struct_member(common_blue, detail_blue); + TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_blue); + } + CompleteStructType struct_type_ColorAmount = TypeObjectUtils::build_complete_struct_type(struct_flags_ColorAmount, header_ColorAmount, member_seq_ColorAmount); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ColorAmount, type_name_ColorAmount.to_string(), type_ids_ColorAmount)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ColorAmount already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_multi_array_struct_type_identifier( + TypeIdentifierPair& type_ids_multi_array_struct) +{ + + ReturnCode_t return_code_multi_array_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_multi_array_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "multi_array_struct", type_ids_multi_array_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_multi_array_struct) + { + StructTypeFlag struct_flags_multi_array_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_multi_array_struct = "multi_array_struct"; + eprosima::fastcdr::optional type_ann_builtin_multi_array_struct; + eprosima::fastcdr::optional ann_custom_multi_array_struct; + CompleteTypeDetail detail_multi_array_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_multi_array_struct, ann_custom_multi_array_struct, type_name_multi_array_struct.to_string()); + CompleteStructHeader header_multi_array_struct; + header_multi_array_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_multi_array_struct); + CompleteStructMemberSeq member_seq_multi_array_struct; + { + TypeIdentifierPair type_ids_colors; + ReturnCode_t return_code_colors {eprosima::fastdds::dds::RETCODE_OK}; + return_code_colors = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_ColorAmount_5_5_5", type_ids_colors); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_colors) + { + return_code_colors = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ColorAmount", type_ids_colors); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_colors) + { + ::register_ColorAmount_type_identifier(type_ids_colors); + } + bool element_identifier_anonymous_array_ColorAmount_5_5_5_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_ColorAmount_5_5_5 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_colors, element_identifier_anonymous_array_ColorAmount_5_5_5_ec))}; + if (!element_identifier_anonymous_array_ColorAmount_5_5_5_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_ColorAmount_5_5_5 = EK_COMPLETE; + if (TK_NONE == type_ids_colors.type_identifier2()._d()) + { + equiv_kind_anonymous_array_ColorAmount_5_5_5 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_ColorAmount_5_5_5 = 0; + PlainCollectionHeader header_anonymous_array_ColorAmount_5_5_5 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_ColorAmount_5_5_5, element_flags_anonymous_array_ColorAmount_5_5_5); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); + + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); + + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_ColorAmount_5_5_5, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_ColorAmount_5_5_5)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_ColorAmount_5_5_5", type_ids_colors)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_ColorAmount_5_5_5 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_colors = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_colors = 0x00000000; + bool common_colors_ec {false}; + CommonStructMember common_colors {TypeObjectUtils::build_common_struct_member(member_id_colors, member_flags_colors, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_colors, common_colors_ec))}; + if (!common_colors_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure colors member TypeIdentifier inconsistent."); + return; + } + MemberName name_colors = "colors"; + eprosima::fastcdr::optional member_ann_builtin_colors; + ann_custom_multi_array_struct.reset(); + CompleteMemberDetail detail_colors = TypeObjectUtils::build_complete_member_detail(name_colors, member_ann_builtin_colors, ann_custom_multi_array_struct); + CompleteStructMember member_colors = TypeObjectUtils::build_complete_struct_member(common_colors, detail_colors); + TypeObjectUtils::add_complete_struct_member(member_seq_multi_array_struct, member_colors); + } + CompleteStructType struct_type_multi_array_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_multi_array_struct, header_multi_array_struct, member_seq_multi_array_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_multi_array_struct, type_name_multi_array_struct.to_string(), type_ids_multi_array_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "multi_array_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..93bb42861d5 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp @@ -0,0 +1,68 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file multi_array_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register ColorAmount related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ColorAmount_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register multi_array_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_multi_array_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash b/test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash deleted file mode 100644 index aab6d044350..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/regenerate_types.bash +++ /dev/null @@ -1,21 +0,0 @@ -#!/bin/bash - -# Define the root directory containing the folders -root_dir="/home/daniel/Documents/eprosima/dynamic_type_idl/src/fastdds/test/unittest/dds/xtypes/type_conversion/types/type_objects" - -# Iterate through each folder in the root directory -for folder in "$root_dir"/*/; do - # Extract the folder name - folder_name=$(basename "$folder") - - # Change to the folder - cd "$folder" || exit - - # Run the commands - cp "../../idls/${folder_name}.idl" . - /home/daniel/Documents/fastddsgen/scripts/fastddsgen -replace "${folder_name}.idl" - rm "${folder_name}.idl" - - # Change back to the root directory - cd "$root_dir" || exit -done diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp new file mode 100644 index 00000000000..23a51572101 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp @@ -0,0 +1,331 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__STRING_STRUCT_HPP +#define FAST_DDS_GENERATED__STRING_STRUCT_HPP + +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(STRING_STRUCT_SOURCE) +#define STRING_STRUCT_DllAPI __declspec( dllexport ) +#else +#define STRING_STRUCT_DllAPI __declspec( dllimport ) +#endif // STRING_STRUCT_SOURCE +#else +#define STRING_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define STRING_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure string_struct defined by the user in the IDL file. + * @ingroup string_struct + */ +class string_struct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport string_struct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~string_struct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object string_struct that will be copied. + */ + eProsima_user_DllExport string_struct( + const string_struct& x) + { + m_my_string = x.m_my_string; + + m_my_wstring = x.m_my_wstring; + + m_my_bounded_string = x.m_my_bounded_string; + + m_my_bounded_wstring = x.m_my_bounded_wstring; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object string_struct that will be copied. + */ + eProsima_user_DllExport string_struct( + string_struct&& x) noexcept + { + m_my_string = std::move(x.m_my_string); + m_my_wstring = std::move(x.m_my_wstring); + m_my_bounded_string = std::move(x.m_my_bounded_string); + m_my_bounded_wstring = std::move(x.m_my_bounded_wstring); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object string_struct that will be copied. + */ + eProsima_user_DllExport string_struct& operator =( + const string_struct& x) + { + + m_my_string = x.m_my_string; + + m_my_wstring = x.m_my_wstring; + + m_my_bounded_string = x.m_my_bounded_string; + + m_my_bounded_wstring = x.m_my_bounded_wstring; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object string_struct that will be copied. + */ + eProsima_user_DllExport string_struct& operator =( + string_struct&& x) noexcept + { + + m_my_string = std::move(x.m_my_string); + m_my_wstring = std::move(x.m_my_wstring); + m_my_bounded_string = std::move(x.m_my_bounded_string); + m_my_bounded_wstring = std::move(x.m_my_bounded_wstring); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x string_struct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const string_struct& x) const + { + return (m_my_string == x.m_my_string && + m_my_wstring == x.m_my_wstring && + m_my_bounded_string == x.m_my_bounded_string && + m_my_bounded_wstring == x.m_my_bounded_wstring); + } + + /*! + * @brief Comparison operator. + * @param x string_struct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const string_struct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_string + * @param _my_string New value to be copied in member my_string + */ + eProsima_user_DllExport void my_string( + const std::string& _my_string) + { + m_my_string = _my_string; + } + + /*! + * @brief This function moves the value in member my_string + * @param _my_string New value to be moved in member my_string + */ + eProsima_user_DllExport void my_string( + std::string&& _my_string) + { + m_my_string = std::move(_my_string); + } + + /*! + * @brief This function returns a constant reference to member my_string + * @return Constant reference to member my_string + */ + eProsima_user_DllExport const std::string& my_string() const + { + return m_my_string; + } + + /*! + * @brief This function returns a reference to member my_string + * @return Reference to member my_string + */ + eProsima_user_DllExport std::string& my_string() + { + return m_my_string; + } + + + /*! + * @brief This function copies the value in member my_wstring + * @param _my_wstring New value to be copied in member my_wstring + */ + eProsima_user_DllExport void my_wstring( + const std::wstring& _my_wstring) + { + m_my_wstring = _my_wstring; + } + + /*! + * @brief This function moves the value in member my_wstring + * @param _my_wstring New value to be moved in member my_wstring + */ + eProsima_user_DllExport void my_wstring( + std::wstring&& _my_wstring) + { + m_my_wstring = std::move(_my_wstring); + } + + /*! + * @brief This function returns a constant reference to member my_wstring + * @return Constant reference to member my_wstring + */ + eProsima_user_DllExport const std::wstring& my_wstring() const + { + return m_my_wstring; + } + + /*! + * @brief This function returns a reference to member my_wstring + * @return Reference to member my_wstring + */ + eProsima_user_DllExport std::wstring& my_wstring() + { + return m_my_wstring; + } + + + /*! + * @brief This function copies the value in member my_bounded_string + * @param _my_bounded_string New value to be copied in member my_bounded_string + */ + eProsima_user_DllExport void my_bounded_string( + const eprosima::fastcdr::fixed_string<41925>& _my_bounded_string) + { + m_my_bounded_string = _my_bounded_string; + } + + /*! + * @brief This function moves the value in member my_bounded_string + * @param _my_bounded_string New value to be moved in member my_bounded_string + */ + eProsima_user_DllExport void my_bounded_string( + eprosima::fastcdr::fixed_string<41925>&& _my_bounded_string) + { + m_my_bounded_string = std::move(_my_bounded_string); + } + + /*! + * @brief This function returns a constant reference to member my_bounded_string + * @return Constant reference to member my_bounded_string + */ + eProsima_user_DllExport const eprosima::fastcdr::fixed_string<41925>& my_bounded_string() const + { + return m_my_bounded_string; + } + + /*! + * @brief This function returns a reference to member my_bounded_string + * @return Reference to member my_bounded_string + */ + eProsima_user_DllExport eprosima::fastcdr::fixed_string<41925>& my_bounded_string() + { + return m_my_bounded_string; + } + + + /*! + * @brief This function copies the value in member my_bounded_wstring + * @param _my_bounded_wstring New value to be copied in member my_bounded_wstring + */ + eProsima_user_DllExport void my_bounded_wstring( + const std::wstring& _my_bounded_wstring) + { + m_my_bounded_wstring = _my_bounded_wstring; + } + + /*! + * @brief This function moves the value in member my_bounded_wstring + * @param _my_bounded_wstring New value to be moved in member my_bounded_wstring + */ + eProsima_user_DllExport void my_bounded_wstring( + std::wstring&& _my_bounded_wstring) + { + m_my_bounded_wstring = std::move(_my_bounded_wstring); + } + + /*! + * @brief This function returns a constant reference to member my_bounded_wstring + * @return Constant reference to member my_bounded_wstring + */ + eProsima_user_DllExport const std::wstring& my_bounded_wstring() const + { + return m_my_bounded_wstring; + } + + /*! + * @brief This function returns a reference to member my_bounded_wstring + * @return Reference to member my_bounded_wstring + */ + eProsima_user_DllExport std::wstring& my_bounded_wstring() + { + return m_my_bounded_wstring; + } + + + +private: + + std::string m_my_string; + std::wstring m_my_wstring; + eprosima::fastcdr::fixed_string<41925> m_my_bounded_string; + std::wstring m_my_bounded_wstring; + +}; + +#endif // _FAST_DDS_GENERATED_STRING_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp new file mode 100644 index 00000000000..c5abbd1de8c --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_HPP + +#include "string_struct.hpp" + +constexpr uint32_t string_struct_max_cdr_typesize {84566UL}; +constexpr uint32_t string_struct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const string_struct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp new file mode 100644 index 00000000000..ef03a319ea5 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp @@ -0,0 +1,142 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_IPP + +#include "string_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const string_struct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_string(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_wstring(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_bounded_string(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_bounded_wstring(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const string_struct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_string() + << eprosima::fastcdr::MemberId(1) << data.my_wstring() + << eprosima::fastcdr::MemberId(2) << data.my_bounded_string() + << eprosima::fastcdr::MemberId(3) << data.my_bounded_wstring() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + string_struct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_string(); + break; + + case 1: + dcdr >> data.my_wstring(); + break; + + case 2: + dcdr >> data.my_bounded_string(); + break; + + case 3: + dcdr >> data.my_bounded_wstring(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const string_struct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__STRING_STRUCTCDRAUX_IPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx new file mode 100644 index 00000000000..0a1ebdfde3d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "string_structPubSubTypes.hpp" + +#include +#include + +#include "string_structCdrAux.hpp" +#include "string_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +string_structPubSubType::string_structPubSubType() +{ + setName("string_struct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(string_struct::getMaxCdrSerializedSize()); +#else + string_struct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = string_struct_max_key_cdr_typesize > 16 ? string_struct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +string_structPubSubType::~string_structPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool string_structPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const string_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool string_structPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + string_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function string_structPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* string_structPubSubType::createData() +{ + return reinterpret_cast(new string_struct()); +} + +void string_structPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool string_structPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const string_struct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + string_struct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || string_struct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void string_structPubSubType::register_type_object_representation() +{ + register_string_struct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "string_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp new file mode 100644 index 00000000000..fbe45bbfb16 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structPubSubTypes.hpp + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef FAST_DDS_GENERATED__STRING_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__STRING_STRUCT_PUBSUBTYPES_HPP + +#include +#include +#include +#include +#include + +#include "string_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated string_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type string_struct defined by the user in the IDL file. + * @ingroup string_struct + */ +class string_structPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef string_struct type; + + eProsima_user_DllExport string_structPubSubType(); + + eProsima_user_DllExport ~string_structPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // FAST_DDS_GENERATED__STRING_STRUCT_PUBSUBTYPES_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..c0fcc4a949b --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx @@ -0,0 +1,222 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "string_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "string_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_string_struct_type_identifier( + TypeIdentifierPair& type_ids_string_struct) +{ + + ReturnCode_t return_code_string_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_string_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "string_struct", type_ids_string_struct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_string_struct) + { + StructTypeFlag struct_flags_string_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_string_struct = "string_struct"; + eprosima::fastcdr::optional type_ann_builtin_string_struct; + eprosima::fastcdr::optional ann_custom_string_struct; + CompleteTypeDetail detail_string_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_string_struct, ann_custom_string_struct, type_name_string_struct.to_string()); + CompleteStructHeader header_string_struct; + header_string_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_string_struct); + CompleteStructMemberSeq member_seq_string_struct; + { + TypeIdentifierPair type_ids_my_string; + ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_string) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_string = 0x00000000; + bool common_my_string_ec {false}; + CommonStructMember common_my_string {TypeObjectUtils::build_common_struct_member(member_id_my_string, member_flags_my_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_string, common_my_string_ec))}; + if (!common_my_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_string = "my_string"; + eprosima::fastcdr::optional member_ann_builtin_my_string; + ann_custom_string_struct.reset(); + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_string_struct); + CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_string); + } + { + TypeIdentifierPair type_ids_my_wstring; + ReturnCode_t return_code_my_wstring {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_wstring = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_wstring_unbounded", type_ids_my_wstring); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_wstring) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_wstring_unbounded", type_ids_my_wstring, true)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_wstring_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_wstring = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_wstring = 0x00000001; + bool common_my_wstring_ec {false}; + CommonStructMember common_my_wstring {TypeObjectUtils::build_common_struct_member(member_id_my_wstring, member_flags_my_wstring, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_wstring, common_my_wstring_ec))}; + if (!common_my_wstring_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_wstring member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_wstring = "my_wstring"; + eprosima::fastcdr::optional member_ann_builtin_my_wstring; + ann_custom_string_struct.reset(); + CompleteMemberDetail detail_my_wstring = TypeObjectUtils::build_complete_member_detail(name_my_wstring, member_ann_builtin_my_wstring, ann_custom_string_struct); + CompleteStructMember member_my_wstring = TypeObjectUtils::build_complete_struct_member(common_my_wstring, detail_my_wstring); + TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_wstring); + } + { + TypeIdentifierPair type_ids_my_bounded_string; + ReturnCode_t return_code_my_bounded_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bounded_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_41925", type_ids_my_bounded_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bounded_string) + { + { + LBound bound = 41925; + StringLTypeDefn string_ldefn = TypeObjectUtils::build_string_l_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_l_string_type_identifier(string_ldefn, + "anonymous_string_41925", type_ids_my_bounded_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_41925 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_bounded_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bounded_string = 0x00000002; + bool common_my_bounded_string_ec {false}; + CommonStructMember common_my_bounded_string {TypeObjectUtils::build_common_struct_member(member_id_my_bounded_string, member_flags_my_bounded_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bounded_string, common_my_bounded_string_ec))}; + if (!common_my_bounded_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bounded_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bounded_string = "my_bounded_string"; + eprosima::fastcdr::optional member_ann_builtin_my_bounded_string; + ann_custom_string_struct.reset(); + CompleteMemberDetail detail_my_bounded_string = TypeObjectUtils::build_complete_member_detail(name_my_bounded_string, member_ann_builtin_my_bounded_string, ann_custom_string_struct); + CompleteStructMember member_my_bounded_string = TypeObjectUtils::build_complete_struct_member(common_my_bounded_string, detail_my_bounded_string); + TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_bounded_string); + } + { + TypeIdentifierPair type_ids_my_bounded_wstring; + ReturnCode_t return_code_my_bounded_wstring {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bounded_wstring = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_wstring_20925", type_ids_my_bounded_wstring); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bounded_wstring) + { + { + LBound bound = 20925; + StringLTypeDefn string_ldefn = TypeObjectUtils::build_string_l_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_l_string_type_identifier(string_ldefn, + "anonymous_wstring_20925", type_ids_my_bounded_wstring, true)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_wstring_20925 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_bounded_wstring = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bounded_wstring = 0x00000003; + bool common_my_bounded_wstring_ec {false}; + CommonStructMember common_my_bounded_wstring {TypeObjectUtils::build_common_struct_member(member_id_my_bounded_wstring, member_flags_my_bounded_wstring, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bounded_wstring, common_my_bounded_wstring_ec))}; + if (!common_my_bounded_wstring_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bounded_wstring member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bounded_wstring = "my_bounded_wstring"; + eprosima::fastcdr::optional member_ann_builtin_my_bounded_wstring; + ann_custom_string_struct.reset(); + CompleteMemberDetail detail_my_bounded_wstring = TypeObjectUtils::build_complete_member_detail(name_my_bounded_wstring, member_ann_builtin_my_bounded_wstring, ann_custom_string_struct); + CompleteStructMember member_my_bounded_wstring = TypeObjectUtils::build_complete_struct_member(common_my_bounded_wstring, detail_my_bounded_wstring); + TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_bounded_wstring); + } + CompleteStructType struct_type_string_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_string_struct, header_string_struct, member_seq_string_struct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_string_struct, type_name_string_struct.to_string(), type_ids_string_struct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "string_struct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..ce3dac4c5ab --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file string_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__STRING_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__STRING_STRUCT_TYPE_OBJECT_SUPPORT_HPP + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register string_struct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_string_struct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // FAST_DDS_GENERATED__STRING_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp index 4ec3a99c441..a71b1d67661 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp @@ -55,24 +55,25 @@ #endif // _WIN32 /*! - * @brief This class represents the union MyUnion defined by the user in the IDL file. + * @brief This class represents the union BasicUnion defined by the user in the IDL file. * @ingroup union_struct */ -class MyUnion +class BasicUnion { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport MyUnion() + eProsima_user_DllExport BasicUnion() { + second_(); } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~MyUnion() + eProsima_user_DllExport ~BasicUnion() { if (member_destructor_) { @@ -82,25 +83,21 @@ class MyUnion /*! * @brief Copy constructor. - * @param x Reference to the object MyUnion that will be copied. + * @param x Reference to the object BasicUnion that will be copied. */ - eProsima_user_DllExport MyUnion( - const MyUnion& x) + eProsima_user_DllExport BasicUnion( + const BasicUnion& x) { m__d = x.m__d; switch (x.selected_member_) { case 0x00000001: - octet_value_() = x.m_octet_value; + first_() = x.m_first; break; case 0x00000002: - long_value_() = x.m_long_value; - break; - - case 0x00000003: - string_value_() = x.m_string_value; + second_() = x.m_second; break; } @@ -108,25 +105,21 @@ class MyUnion /*! * @brief Move constructor. - * @param x Reference to the object MyUnion that will be copied. + * @param x Reference to the object BasicUnion that will be copied. */ - eProsima_user_DllExport MyUnion( - MyUnion&& x) noexcept + eProsima_user_DllExport BasicUnion( + BasicUnion&& x) noexcept { m__d = x.m__d; switch (x.selected_member_) { case 0x00000001: - octet_value_() = std::move(x.m_octet_value); + first_() = std::move(x.m_first); break; case 0x00000002: - long_value_() = std::move(x.m_long_value); - break; - - case 0x00000003: - string_value_() = std::move(x.m_string_value); + second_() = std::move(x.m_second); break; } @@ -134,25 +127,21 @@ class MyUnion /*! * @brief Copy assignment. - * @param x Reference to the object MyUnion that will be copied. + * @param x Reference to the object BasicUnion that will be copied. */ - eProsima_user_DllExport MyUnion& operator =( - const MyUnion& x) + eProsima_user_DllExport BasicUnion& operator =( + const BasicUnion& x) { m__d = x.m__d; switch (x.selected_member_) { case 0x00000001: - octet_value_() = x.m_octet_value; + first_() = x.m_first; break; case 0x00000002: - long_value_() = x.m_long_value; - break; - - case 0x00000003: - string_value_() = x.m_string_value; + second_() = x.m_second; break; } @@ -162,25 +151,21 @@ class MyUnion /*! * @brief Move assignment. - * @param x Reference to the object MyUnion that will be copied. + * @param x Reference to the object BasicUnion that will be copied. */ - eProsima_user_DllExport MyUnion& operator =( - MyUnion&& x) noexcept + eProsima_user_DllExport BasicUnion& operator =( + BasicUnion&& x) noexcept { m__d = x.m__d; switch (x.selected_member_) { case 0x00000001: - octet_value_() = std::move(x.m_octet_value); + first_() = std::move(x.m_first); break; case 0x00000002: - long_value_() = std::move(x.m_long_value); - break; - - case 0x00000003: - string_value_() = std::move(x.m_string_value); + second_() = std::move(x.m_second); break; } @@ -190,10 +175,10 @@ class MyUnion /*! * @brief Comparison operator. - * @param x MyUnion object to compare. + * @param x BasicUnion object to compare. */ eProsima_user_DllExport bool operator ==( - const MyUnion& x) const + const BasicUnion& x) const { bool ret_value {false}; @@ -203,15 +188,11 @@ class MyUnion switch (selected_member_) { case 0x00000001: - ret_value = (m_octet_value == x.m_octet_value); + ret_value = (m_first == x.m_first); break; case 0x00000002: - ret_value = (m_long_value == x.m_long_value); - break; - - case 0x00000003: - ret_value = (m_string_value == x.m_string_value); + ret_value = (m_second == x.m_second); break; } @@ -222,10 +203,10 @@ class MyUnion /*! * @brief Comparison operator. - * @param x MyUnion object to compare. + * @param x BasicUnion object to compare. */ eProsima_user_DllExport bool operator !=( - const MyUnion& x) const + const BasicUnion& x) const { return !(*this == x); } @@ -236,33 +217,27 @@ class MyUnion * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the new value doesn't correspond to the selected union member. */ eProsima_user_DllExport void _d( - int32_t __d) + int16_t __d) { bool valid_discriminator = false; switch (__d) { - case 1: + case 0: if (0x00000001 == selected_member_) { valid_discriminator = true; } break; - case 2: + case 1: + default: if (0x00000002 == selected_member_) { valid_discriminator = true; } break; - case 3: - if (0x00000003 == selected_member_) - { - valid_discriminator = true; - } - break; - } if (!valid_discriminator) @@ -277,162 +252,460 @@ class MyUnion * @brief This function returns the value of the discriminator. * @return Value of the discriminator */ - eProsima_user_DllExport int32_t _d() const + eProsima_user_DllExport int16_t _d() const { return m__d; } /*! - * @brief This function sets a value in member octet_value - * @param _octet_value New value for member octet_value + * @brief This function copies the value in member first + * @param _first New value to be copied in member first */ - eProsima_user_DllExport void octet_value( - uint8_t _octet_value) + eProsima_user_DllExport void first( + const std::string& _first) { - octet_value_() = _octet_value; - m__d = 1; + first_() = _first; + m__d = 0; } /*! - * @brief This function returns the value of member octet_value - * @return Value of member octet_value + * @brief This function moves the value in member first + * @param _first New value to be moved in member first + */ + eProsima_user_DllExport void first( + std::string&& _first) + { + first_() = _first; + m__d = 0; + } + + /*! + * @brief This function returns a constant reference to member first + * @return Constant reference to member first * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport uint8_t octet_value() const + eProsima_user_DllExport const std::string& first() const { if (0x00000001 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_octet_value; + return m_first; } /*! - * @brief This function returns a reference to member octet_value - * @return Reference to member octet_value + * @brief This function returns a reference to member first + * @return Reference to member first * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport uint8_t& octet_value() + eProsima_user_DllExport std::string& first() { if (0x00000001 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_octet_value; + return m_first; } /*! - * @brief This function sets a value in member long_value - * @param _long_value New value for member long_value + * @brief This function sets a value in member second + * @param _second New value for member second */ - eProsima_user_DllExport void long_value( - int32_t _long_value) + eProsima_user_DllExport void second( + int64_t _second) { - long_value_() = _long_value; + second_() = _second; m__d = 2; } /*! - * @brief This function returns the value of member long_value - * @return Value of member long_value + * @brief This function returns the value of member second + * @return Value of member second * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport int32_t long_value() const + eProsima_user_DllExport int64_t second() const { if (0x00000002 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_long_value; + return m_second; } /*! - * @brief This function returns a reference to member long_value - * @return Reference to member long_value + * @brief This function returns a reference to member second + * @return Reference to member second * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport int32_t& long_value() + eProsima_user_DllExport int64_t& second() { if (0x00000002 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_long_value; + return m_second; + } + + + +private: + + std::string& first_() + { + if (0x00000001 != selected_member_) + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x00000001; + member_destructor_ = [&]() {m_first.~basic_string();}; + new(&m_first) std::string(); + ; + } + + return m_first; + } + + int64_t& second_() + { + if (0x00000002 != selected_member_) + { + if (member_destructor_) + { + member_destructor_(); + } + + selected_member_ = 0x00000002; + member_destructor_ = nullptr; + m_second = {0}; + ; + } + + return m_second; + } + + + int16_t m__d {2}; + + union + { + std::string m_first; + int64_t m_second; + }; + + uint32_t selected_member_ {0x0FFFFFFFu}; + + std::function member_destructor_; +}; +/*! + * @brief This class represents the union ComplexUnion defined by the user in the IDL file. + * @ingroup union_struct + */ +class ComplexUnion +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ComplexUnion() + { + fourth_(); + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ComplexUnion() + { + if (member_destructor_) + { + member_destructor_(); + } + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ComplexUnion that will be copied. + */ + eProsima_user_DllExport ComplexUnion( + const ComplexUnion& x) + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + third_() = x.m_third; + break; + + case 0x00000002: + fourth_() = x.m_fourth; + break; + + } + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ComplexUnion that will be copied. + */ + eProsima_user_DllExport ComplexUnion( + ComplexUnion&& x) noexcept + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + third_() = std::move(x.m_third); + break; + + case 0x00000002: + fourth_() = std::move(x.m_fourth); + break; + + } + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ComplexUnion that will be copied. + */ + eProsima_user_DllExport ComplexUnion& operator =( + const ComplexUnion& x) + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + third_() = x.m_third; + break; + + case 0x00000002: + fourth_() = x.m_fourth; + break; + + } + + return *this; } + /*! + * @brief Move assignment. + * @param x Reference to the object ComplexUnion that will be copied. + */ + eProsima_user_DllExport ComplexUnion& operator =( + ComplexUnion&& x) noexcept + { + m__d = x.m__d; + + switch (x.selected_member_) + { + case 0x00000001: + third_() = std::move(x.m_third); + break; + + case 0x00000002: + fourth_() = std::move(x.m_fourth); + break; + + } + + return *this; + } /*! - * @brief This function copies the value in member string_value - * @param _string_value New value to be copied in member string_value + * @brief Comparison operator. + * @param x ComplexUnion object to compare. */ - eProsima_user_DllExport void string_value( - const std::string& _string_value) + eProsima_user_DllExport bool operator ==( + const ComplexUnion& x) const { - string_value_() = _string_value; - m__d = 3; + bool ret_value {false}; + + if (m__d == x.m__d && + selected_member_ == x.selected_member_) + { + switch (selected_member_) + { + case 0x00000001: + ret_value = (m_third == x.m_third); + break; + + case 0x00000002: + ret_value = (m_fourth == x.m_fourth); + break; + + } + } + + return ret_value; } /*! - * @brief This function moves the value in member string_value - * @param _string_value New value to be moved in member string_value + * @brief Comparison operator. + * @param x ComplexUnion object to compare. */ - eProsima_user_DllExport void string_value( - std::string&& _string_value) + eProsima_user_DllExport bool operator !=( + const ComplexUnion& x) const { - string_value_() = _string_value; - m__d = 3; + return !(*this == x); } /*! - * @brief This function returns a constant reference to member string_value - * @return Constant reference to member string_value + * @brief This function sets the discriminator value. + * @param __d New value for the discriminator. + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the new value doesn't correspond to the selected union member. + */ + eProsima_user_DllExport void _d( + int32_t __d) + { + bool valid_discriminator = false; + + switch (__d) + { + case 0: + case 1: + if (0x00000001 == selected_member_) + { + valid_discriminator = true; + } + break; + + default: + if (0x00000002 == selected_member_) + { + valid_discriminator = true; + } + break; + + } + + if (!valid_discriminator) + { + throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member"); + } + + m__d = __d; + } + + /*! + * @brief This function returns the value of the discriminator. + * @return Value of the discriminator + */ + eProsima_user_DllExport int32_t _d() const + { + return m__d; + } + + /*! + * @brief This function sets a value in member third + * @param _third New value for member third + */ + eProsima_user_DllExport void third( + int32_t _third) + { + third_() = _third; + m__d = 0; + } + + /*! + * @brief This function returns the value of member third + * @return Value of member third * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport const std::string& string_value() const + eProsima_user_DllExport int32_t third() const { - if (0x00000003 != selected_member_) + if (0x00000001 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_string_value; + return m_third; } /*! - * @brief This function returns a reference to member string_value - * @return Reference to member string_value + * @brief This function returns a reference to member third + * @return Reference to member third * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. */ - eProsima_user_DllExport std::string& string_value() + eProsima_user_DllExport int32_t& third() { - if (0x00000003 != selected_member_) + if (0x00000001 != selected_member_) { throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - return m_string_value; + return m_third; } - void _default() + /*! + * @brief This function copies the value in member fourth + * @param _fourth New value to be copied in member fourth + */ + eProsima_user_DllExport void fourth( + const BasicUnion& _fourth) { - if (member_destructor_) + fourth_() = _fourth; + m__d = 2; + } + + /*! + * @brief This function moves the value in member fourth + * @param _fourth New value to be moved in member fourth + */ + eProsima_user_DllExport void fourth( + BasicUnion&& _fourth) + { + fourth_() = _fourth; + m__d = 2; + } + + /*! + * @brief This function returns a constant reference to member fourth + * @return Constant reference to member fourth + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport const BasicUnion& fourth() const + { + if (0x00000002 != selected_member_) { - member_destructor_(); + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); + } + + return m_fourth; + } + + /*! + * @brief This function returns a reference to member fourth + * @return Reference to member fourth + * @exception eprosima::fastcdr::exception::BadParamException This exception is thrown if the requested union member is not the current selection. + */ + eProsima_user_DllExport BasicUnion& fourth() + { + if (0x00000002 != selected_member_) + { + throw eprosima::fastcdr::exception::BadParamException("This member has not been selected"); } - selected_member_ = 0x0FFFFFFFu; + return m_fourth; } + private: - uint8_t& octet_value_() + int32_t& third_() { if (0x00000001 != selected_member_) { @@ -443,14 +716,14 @@ class MyUnion selected_member_ = 0x00000001; member_destructor_ = nullptr; - m_octet_value = {0}; + m_third = {0}; ; } - return m_octet_value; + return m_third; } - int32_t& long_value_() + BasicUnion& fourth_() { if (0x00000002 != selected_member_) { @@ -460,40 +733,21 @@ class MyUnion } selected_member_ = 0x00000002; - member_destructor_ = nullptr; - m_long_value = {0}; + member_destructor_ = [&]() {m_fourth.~BasicUnion();}; + new(&m_fourth) BasicUnion(); ; } - return m_long_value; + return m_fourth; } - std::string& string_value_() - { - if (0x00000003 != selected_member_) - { - if (member_destructor_) - { - member_destructor_(); - } - selected_member_ = 0x00000003; - member_destructor_ = [&]() {m_string_value.~basic_string();}; - new(&m_string_value) std::string(); - ; - } - - return m_string_value; - } - - - int32_t m__d {0}; + int32_t m__d {2}; union { - uint8_t m_octet_value; - int32_t m_long_value; - std::string m_string_value; + int32_t m_third; + BasicUnion m_fourth; }; uint32_t selected_member_ {0x0FFFFFFFu}; @@ -529,9 +783,9 @@ class union_struct eProsima_user_DllExport union_struct( const union_struct& x) { - m_index = x.m_index; + m_my_basic_union = x.m_my_basic_union; - m_union_value = x.m_union_value; + m_my_complex_union = x.m_my_complex_union; } @@ -542,8 +796,8 @@ class union_struct eProsima_user_DllExport union_struct( union_struct&& x) noexcept { - m_index = x.m_index; - m_union_value = std::move(x.m_union_value); + m_my_basic_union = std::move(x.m_my_basic_union); + m_my_complex_union = std::move(x.m_my_complex_union); } /*! @@ -554,9 +808,9 @@ class union_struct const union_struct& x) { - m_index = x.m_index; + m_my_basic_union = x.m_my_basic_union; - m_union_value = x.m_union_value; + m_my_complex_union = x.m_my_complex_union; return *this; } @@ -569,8 +823,8 @@ class union_struct union_struct&& x) noexcept { - m_index = x.m_index; - m_union_value = std::move(x.m_union_value); + m_my_basic_union = std::move(x.m_my_basic_union); + m_my_complex_union = std::move(x.m_my_complex_union); return *this; } @@ -581,8 +835,8 @@ class union_struct eProsima_user_DllExport bool operator ==( const union_struct& x) const { - return (m_index == x.m_index && - m_union_value == x.m_union_value); + return (m_my_basic_union == x.m_my_basic_union && + m_my_complex_union == x.m_my_complex_union); } /*! @@ -596,78 +850,88 @@ class union_struct } /*! - * @brief This function sets a value in member index - * @param _index New value for member index + * @brief This function copies the value in member my_basic_union + * @param _my_basic_union New value to be copied in member my_basic_union + */ + eProsima_user_DllExport void my_basic_union( + const BasicUnion& _my_basic_union) + { + m_my_basic_union = _my_basic_union; + } + + /*! + * @brief This function moves the value in member my_basic_union + * @param _my_basic_union New value to be moved in member my_basic_union */ - eProsima_user_DllExport void index( - uint32_t _index) + eProsima_user_DllExport void my_basic_union( + BasicUnion&& _my_basic_union) { - m_index = _index; + m_my_basic_union = std::move(_my_basic_union); } /*! - * @brief This function returns the value of member index - * @return Value of member index + * @brief This function returns a constant reference to member my_basic_union + * @return Constant reference to member my_basic_union */ - eProsima_user_DllExport uint32_t index() const + eProsima_user_DllExport const BasicUnion& my_basic_union() const { - return m_index; + return m_my_basic_union; } /*! - * @brief This function returns a reference to member index - * @return Reference to member index + * @brief This function returns a reference to member my_basic_union + * @return Reference to member my_basic_union */ - eProsima_user_DllExport uint32_t& index() + eProsima_user_DllExport BasicUnion& my_basic_union() { - return m_index; + return m_my_basic_union; } /*! - * @brief This function copies the value in member union_value - * @param _union_value New value to be copied in member union_value + * @brief This function copies the value in member my_complex_union + * @param _my_complex_union New value to be copied in member my_complex_union */ - eProsima_user_DllExport void union_value( - const MyUnion& _union_value) + eProsima_user_DllExport void my_complex_union( + const ComplexUnion& _my_complex_union) { - m_union_value = _union_value; + m_my_complex_union = _my_complex_union; } /*! - * @brief This function moves the value in member union_value - * @param _union_value New value to be moved in member union_value + * @brief This function moves the value in member my_complex_union + * @param _my_complex_union New value to be moved in member my_complex_union */ - eProsima_user_DllExport void union_value( - MyUnion&& _union_value) + eProsima_user_DllExport void my_complex_union( + ComplexUnion&& _my_complex_union) { - m_union_value = std::move(_union_value); + m_my_complex_union = std::move(_my_complex_union); } /*! - * @brief This function returns a constant reference to member union_value - * @return Constant reference to member union_value + * @brief This function returns a constant reference to member my_complex_union + * @return Constant reference to member my_complex_union */ - eProsima_user_DllExport const MyUnion& union_value() const + eProsima_user_DllExport const ComplexUnion& my_complex_union() const { - return m_union_value; + return m_my_complex_union; } /*! - * @brief This function returns a reference to member union_value - * @return Reference to member union_value + * @brief This function returns a reference to member my_complex_union + * @return Reference to member my_complex_union */ - eProsima_user_DllExport MyUnion& union_value() + eProsima_user_DllExport ComplexUnion& my_complex_union() { - return m_union_value; + return m_my_complex_union; } private: - uint32_t m_index{0}; - MyUnion m_union_value; + BasicUnion m_my_basic_union; + ComplexUnion m_my_complex_union; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp index 6a6d3b85a03..1e08a5cf875 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp @@ -24,7 +24,7 @@ #include "union_struct.hpp" -constexpr uint32_t union_struct_max_cdr_typesize {276UL}; +constexpr uint32_t union_struct_max_cdr_typesize {548UL}; constexpr uint32_t union_struct_max_key_cdr_typesize {0UL}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp index 372fcc5ac61..608ce5915cf 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const MyUnion& data, + const BasicUnion& data, size_t& current_alignment) { static_cast(data); @@ -54,23 +54,17 @@ eProsima_user_DllExport size_t calculate_serialized_size( switch (data._d()) { - case 1: + case 0: calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.octet_value(), current_alignment); + data.first(), current_alignment); break; - case 2: + case 1: + default: calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.long_value(), current_alignment); - break; - - case 3: - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.string_value(), current_alignment); + data.second(), current_alignment); break; - default: - break; } calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -82,7 +76,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const MyUnion& data) + const BasicUnion& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -94,20 +88,15 @@ eProsima_user_DllExport void serialize( switch (data._d()) { - case 1: - scdr << eprosima::fastcdr::MemberId(1) << data.octet_value(); - break; - - case 2: - scdr << eprosima::fastcdr::MemberId(2) << data.long_value(); + case 0: + scdr << eprosima::fastcdr::MemberId(1) << data.first(); break; - case 3: - scdr << eprosima::fastcdr::MemberId(3) << data.string_value(); + case 1: + default: + scdr << eprosima::fastcdr::MemberId(2) << data.second(); break; - default: - break; } scdr.end_serialize_type(current_state); @@ -116,7 +105,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - MyUnion& data) + BasicUnion& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -126,58 +115,168 @@ eProsima_user_DllExport void deserialize( bool ret_value = true; if (0 == mid.id) { - int32_t discriminator; + int16_t discriminator; dcdr >> discriminator; switch (discriminator) { + case 0: + { + std::string first_value; + data.first(std::move(first_value)); + data._d(discriminator); + break; + } + case 1: + default: { - uint8_t octet_value_value{0}; - data.octet_value(std::move(octet_value_value)); + int64_t second_value{0}; + data.second(std::move(second_value)); data._d(discriminator); break; } - case 2: + } + } + else + { + switch (data._d()) + { + case 0: + dcdr >> data.first(); + break; + + case 1: + default: + dcdr >> data.second(); + break; + + } + ret_value = false; + } + return ret_value; + }); +} + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ComplexUnion& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), data._d(), + current_alignment); + + switch (data._d()) + { + case 0: + case 1: + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.third(), current_alignment); + break; + + default: + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.fourth(), current_alignment); + break; + + } + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const ComplexUnion& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr << eprosima::fastcdr::MemberId(0) << data._d(); + + switch (data._d()) + { + case 0: + case 1: + scdr << eprosima::fastcdr::MemberId(1) << data.third(); + break; + + default: + scdr << eprosima::fastcdr::MemberId(2) << data.fourth(); + break; + + } + + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + ComplexUnion& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + if (0 == mid.id) + { + int32_t discriminator; + dcdr >> discriminator; + + switch (discriminator) + { + case 0: + case 1: { - int32_t long_value_value{0}; - data.long_value(std::move(long_value_value)); + int32_t third_value{0}; + data.third(std::move(third_value)); data._d(discriminator); break; } - case 3: + default: { - std::string string_value_value; - data.string_value(std::move(string_value_value)); + BasicUnion fourth_value; + data.fourth(std::move(fourth_value)); data._d(discriminator); break; } - default: - data._default(); - break; } } else { switch (data._d()) { + case 0: case 1: - dcdr >> data.octet_value(); - break; - - case 2: - dcdr >> data.long_value(); + dcdr >> data.third(); break; - case 3: - dcdr >> data.string_value(); + default: + dcdr >> data.fourth(); break; - default: - break; } ret_value = false; } @@ -202,10 +301,10 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.index(), current_alignment); + data.my_basic_union(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.union_value(), current_alignment); + data.my_complex_union(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -225,8 +324,8 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.index() - << eprosima::fastcdr::MemberId(1) << data.union_value() + << eprosima::fastcdr::MemberId(0) << data.my_basic_union() + << eprosima::fastcdr::MemberId(1) << data.my_complex_union() ; scdr.end_serialize_type(current_state); } @@ -245,11 +344,11 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.index(); + dcdr >> data.my_basic_union(); break; case 1: - dcdr >> data.union_value(); + dcdr >> data.my_complex_union(); break; default: diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx index fd7ed407254..7046d46eb0f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx @@ -39,165 +39,254 @@ using namespace eprosima::fastdds::dds::xtypes; // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_MyUnion_type_identifier( - TypeIdentifierPair& type_ids_MyUnion) +void register_BasicUnion_type_identifier( + TypeIdentifierPair& type_ids_BasicUnion) { - ReturnCode_t return_code_MyUnion {eprosima::fastdds::dds::RETCODE_OK}; - return_code_MyUnion = + ReturnCode_t return_code_BasicUnion {eprosima::fastdds::dds::RETCODE_OK}; + return_code_BasicUnion = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyUnion", type_ids_MyUnion); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + "BasicUnion", type_ids_BasicUnion); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_BasicUnion) { - UnionTypeFlag union_flags_MyUnion = TypeObjectUtils::build_union_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + UnionTypeFlag union_flags_BasicUnion = TypeObjectUtils::build_union_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_MyUnion = "MyUnion"; - eprosima::fastcdr::optional type_ann_builtin_MyUnion; - eprosima::fastcdr::optional ann_custom_MyUnion; - CompleteTypeDetail detail_MyUnion = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyUnion, ann_custom_MyUnion, type_name_MyUnion.to_string()); - CompleteUnionHeader header_MyUnion = TypeObjectUtils::build_complete_union_header(detail_MyUnion); - UnionDiscriminatorFlag member_flags_MyUnion = TypeObjectUtils::build_union_discriminator_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + QualifiedTypeName type_name_BasicUnion = "BasicUnion"; + eprosima::fastcdr::optional type_ann_builtin_BasicUnion; + eprosima::fastcdr::optional ann_custom_BasicUnion; + CompleteTypeDetail detail_BasicUnion = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BasicUnion, ann_custom_BasicUnion, type_name_BasicUnion.to_string()); + CompleteUnionHeader header_BasicUnion = TypeObjectUtils::build_complete_union_header(detail_BasicUnion); + UnionDiscriminatorFlag member_flags_BasicUnion = TypeObjectUtils::build_union_discriminator_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false); - return_code_MyUnion = + return_code_BasicUnion = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_MyUnion); + "_int16_t", type_ids_BasicUnion); - if (return_code_MyUnion != eprosima::fastdds::dds::RETCODE_OK) + if (return_code_BasicUnion != eprosima::fastdds::dds::RETCODE_OK) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union discriminator TypeIdentifier unknown to TypeObjectRegistry."); return; } - CommonDiscriminatorMember common_MyUnion; - if (EK_COMPLETE == type_ids_MyUnion.type_identifier1()._d() || TK_NONE == type_ids_MyUnion.type_identifier2()._d()) + CommonDiscriminatorMember common_BasicUnion; + if (EK_COMPLETE == type_ids_BasicUnion.type_identifier1()._d() || TK_NONE == type_ids_BasicUnion.type_identifier2()._d()) { - common_MyUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_MyUnion, type_ids_MyUnion.type_identifier1()); + common_BasicUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_BasicUnion, type_ids_BasicUnion.type_identifier1()); } - else if (EK_COMPLETE == type_ids_MyUnion.type_identifier2()._d()) + else if (EK_COMPLETE == type_ids_BasicUnion.type_identifier2()._d()) { - common_MyUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_MyUnion, type_ids_MyUnion.type_identifier2()); + common_BasicUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_BasicUnion, type_ids_BasicUnion.type_identifier2()); } else { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "MyUnion discriminator TypeIdentifier inconsistent."); + "BasicUnion discriminator TypeIdentifier inconsistent."); return; } - type_ann_builtin_MyUnion.reset(); - ann_custom_MyUnion.reset(); - CompleteDiscriminatorMember discriminator_MyUnion = TypeObjectUtils::build_complete_discriminator_member(common_MyUnion, - type_ann_builtin_MyUnion, ann_custom_MyUnion); - CompleteUnionMemberSeq member_seq_MyUnion; + type_ann_builtin_BasicUnion.reset(); + ann_custom_BasicUnion.reset(); + CompleteDiscriminatorMember discriminator_BasicUnion = TypeObjectUtils::build_complete_discriminator_member(common_BasicUnion, + type_ann_builtin_BasicUnion, ann_custom_BasicUnion); + CompleteUnionMemberSeq member_seq_BasicUnion; { - return_code_MyUnion = + return_code_BasicUnion = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_byte", type_ids_MyUnion); + "anonymous_string_unbounded", type_ids_BasicUnion); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_BasicUnion) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_BasicUnion)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + UnionMemberFlag member_flags_first = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false); + UnionCaseLabelSeq label_seq_first; + TypeObjectUtils::add_union_case_label(label_seq_first, static_cast(0)); + MemberId member_id_first = 0x00000001; + bool common_first_ec {false}; + CommonUnionMember common_first {TypeObjectUtils::build_common_union_member(member_id_first, + member_flags_first, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BasicUnion, + common_first_ec), label_seq_first)}; + if (!common_first_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union first member TypeIdentifier inconsistent."); + return; + } + MemberName name_first = "first"; + eprosima::fastcdr::optional member_ann_builtin_first; + ann_custom_BasicUnion.reset(); + CompleteMemberDetail detail_first = TypeObjectUtils::build_complete_member_detail(name_first, member_ann_builtin_first, ann_custom_BasicUnion); + CompleteUnionMember member_first = TypeObjectUtils::build_complete_union_member(common_first, detail_first); + TypeObjectUtils::add_complete_union_member(member_seq_BasicUnion, member_first); + } + { + return_code_BasicUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int64_t", type_ids_BasicUnion); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_BasicUnion) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "octet_value Union member TypeIdentifier unknown to TypeObjectRegistry."); + "second Union member TypeIdentifier unknown to TypeObjectRegistry."); return; } - UnionMemberFlag member_flags_octet_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false); - UnionCaseLabelSeq label_seq_octet_value; - TypeObjectUtils::add_union_case_label(label_seq_octet_value, static_cast(1)); - MemberId member_id_octet_value = 0x00000001; - bool common_octet_value_ec {false}; - CommonUnionMember common_octet_value {TypeObjectUtils::build_common_union_member(member_id_octet_value, - member_flags_octet_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, - common_octet_value_ec), label_seq_octet_value)}; - if (!common_octet_value_ec) + UnionMemberFlag member_flags_second = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + true, false); + UnionCaseLabelSeq label_seq_second; + TypeObjectUtils::add_union_case_label(label_seq_second, static_cast(1)); + MemberId member_id_second = 0x00000002; + bool common_second_ec {false}; + CommonUnionMember common_second {TypeObjectUtils::build_common_union_member(member_id_second, + member_flags_second, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BasicUnion, + common_second_ec), label_seq_second)}; + if (!common_second_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union octet_value member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union second member TypeIdentifier inconsistent."); return; } - MemberName name_octet_value = "octet_value"; - eprosima::fastcdr::optional member_ann_builtin_octet_value; - ann_custom_MyUnion.reset(); - CompleteMemberDetail detail_octet_value = TypeObjectUtils::build_complete_member_detail(name_octet_value, member_ann_builtin_octet_value, ann_custom_MyUnion); - CompleteUnionMember member_octet_value = TypeObjectUtils::build_complete_union_member(common_octet_value, detail_octet_value); - TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_octet_value); + MemberName name_second = "second"; + eprosima::fastcdr::optional member_ann_builtin_second; + ann_custom_BasicUnion.reset(); + CompleteMemberDetail detail_second = TypeObjectUtils::build_complete_member_detail(name_second, member_ann_builtin_second, ann_custom_BasicUnion); + CompleteUnionMember member_second = TypeObjectUtils::build_complete_union_member(common_second, detail_second); + TypeObjectUtils::add_complete_union_member(member_seq_BasicUnion, member_second); + } + CompleteUnionType union_type_BasicUnion = TypeObjectUtils::build_complete_union_type(union_flags_BasicUnion, header_BasicUnion, discriminator_BasicUnion, + member_seq_BasicUnion); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_union_type_object(union_type_BasicUnion, type_name_BasicUnion.to_string(), type_ids_BasicUnion)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "BasicUnion already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ComplexUnion_type_identifier( + TypeIdentifierPair& type_ids_ComplexUnion) +{ + ReturnCode_t return_code_ComplexUnion {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ComplexUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexUnion", type_ids_ComplexUnion); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ComplexUnion) + { + UnionTypeFlag union_flags_ComplexUnion = TypeObjectUtils::build_union_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ComplexUnion = "ComplexUnion"; + eprosima::fastcdr::optional type_ann_builtin_ComplexUnion; + eprosima::fastcdr::optional ann_custom_ComplexUnion; + CompleteTypeDetail detail_ComplexUnion = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ComplexUnion, ann_custom_ComplexUnion, type_name_ComplexUnion.to_string()); + CompleteUnionHeader header_ComplexUnion = TypeObjectUtils::build_complete_union_header(detail_ComplexUnion); + UnionDiscriminatorFlag member_flags_ComplexUnion = TypeObjectUtils::build_union_discriminator_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false); + return_code_ComplexUnion = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_ComplexUnion); + + if (return_code_ComplexUnion != eprosima::fastdds::dds::RETCODE_OK) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Union discriminator TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + CommonDiscriminatorMember common_ComplexUnion; + if (EK_COMPLETE == type_ids_ComplexUnion.type_identifier1()._d() || TK_NONE == type_ids_ComplexUnion.type_identifier2()._d()) + { + common_ComplexUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_ComplexUnion, type_ids_ComplexUnion.type_identifier1()); + } + else if (EK_COMPLETE == type_ids_ComplexUnion.type_identifier2()._d()) + { + common_ComplexUnion = TypeObjectUtils::build_common_discriminator_member(member_flags_ComplexUnion, type_ids_ComplexUnion.type_identifier2()); } + else { - return_code_MyUnion = + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ComplexUnion discriminator TypeIdentifier inconsistent."); + return; + } + type_ann_builtin_ComplexUnion.reset(); + ann_custom_ComplexUnion.reset(); + CompleteDiscriminatorMember discriminator_ComplexUnion = TypeObjectUtils::build_complete_discriminator_member(common_ComplexUnion, + type_ann_builtin_ComplexUnion, ann_custom_ComplexUnion); + CompleteUnionMemberSeq member_seq_ComplexUnion; + { + return_code_ComplexUnion = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_MyUnion); + "_int32_t", type_ids_ComplexUnion); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ComplexUnion) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "long_value Union member TypeIdentifier unknown to TypeObjectRegistry."); + "third Union member TypeIdentifier unknown to TypeObjectRegistry."); return; } - UnionMemberFlag member_flags_long_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + UnionMemberFlag member_flags_third = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false); - UnionCaseLabelSeq label_seq_long_value; - TypeObjectUtils::add_union_case_label(label_seq_long_value, static_cast(2)); - MemberId member_id_long_value = 0x00000002; - bool common_long_value_ec {false}; - CommonUnionMember common_long_value {TypeObjectUtils::build_common_union_member(member_id_long_value, - member_flags_long_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, - common_long_value_ec), label_seq_long_value)}; - if (!common_long_value_ec) + UnionCaseLabelSeq label_seq_third; + TypeObjectUtils::add_union_case_label(label_seq_third, static_cast(0)); + TypeObjectUtils::add_union_case_label(label_seq_third, static_cast(1)); + MemberId member_id_third = 0x00000001; + bool common_third_ec {false}; + CommonUnionMember common_third {TypeObjectUtils::build_common_union_member(member_id_third, + member_flags_third, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ComplexUnion, + common_third_ec), label_seq_third)}; + if (!common_third_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union long_value member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union third member TypeIdentifier inconsistent."); return; } - MemberName name_long_value = "long_value"; - eprosima::fastcdr::optional member_ann_builtin_long_value; - ann_custom_MyUnion.reset(); - CompleteMemberDetail detail_long_value = TypeObjectUtils::build_complete_member_detail(name_long_value, member_ann_builtin_long_value, ann_custom_MyUnion); - CompleteUnionMember member_long_value = TypeObjectUtils::build_complete_union_member(common_long_value, detail_long_value); - TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_long_value); + MemberName name_third = "third"; + eprosima::fastcdr::optional member_ann_builtin_third; + ann_custom_ComplexUnion.reset(); + CompleteMemberDetail detail_third = TypeObjectUtils::build_complete_member_detail(name_third, member_ann_builtin_third, ann_custom_ComplexUnion); + CompleteUnionMember member_third = TypeObjectUtils::build_complete_union_member(common_third, detail_third); + TypeObjectUtils::add_complete_union_member(member_seq_ComplexUnion, member_third); } { - return_code_MyUnion = + return_code_ComplexUnion = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_string_unbounded", type_ids_MyUnion); + "BasicUnion", type_ids_ComplexUnion); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyUnion) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ComplexUnion) { - { - SBound bound = 0; - StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, - "anonymous_string_unbounded", type_ids_MyUnion)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); - } - } + ::register_BasicUnion_type_identifier(type_ids_ComplexUnion); } - UnionMemberFlag member_flags_string_value = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false); - UnionCaseLabelSeq label_seq_string_value; - TypeObjectUtils::add_union_case_label(label_seq_string_value, static_cast(3)); - MemberId member_id_string_value = 0x00000003; - bool common_string_value_ec {false}; - CommonUnionMember common_string_value {TypeObjectUtils::build_common_union_member(member_id_string_value, - member_flags_string_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyUnion, - common_string_value_ec), label_seq_string_value)}; - if (!common_string_value_ec) + UnionMemberFlag member_flags_fourth = TypeObjectUtils::build_union_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + true, false); + UnionCaseLabelSeq label_seq_fourth; + MemberId member_id_fourth = 0x00000002; + bool common_fourth_ec {false}; + CommonUnionMember common_fourth {TypeObjectUtils::build_common_union_member(member_id_fourth, + member_flags_fourth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ComplexUnion, + common_fourth_ec), label_seq_fourth)}; + if (!common_fourth_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union string_value member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Union fourth member TypeIdentifier inconsistent."); return; } - MemberName name_string_value = "string_value"; - eprosima::fastcdr::optional member_ann_builtin_string_value; - ann_custom_MyUnion.reset(); - CompleteMemberDetail detail_string_value = TypeObjectUtils::build_complete_member_detail(name_string_value, member_ann_builtin_string_value, ann_custom_MyUnion); - CompleteUnionMember member_string_value = TypeObjectUtils::build_complete_union_member(common_string_value, detail_string_value); - TypeObjectUtils::add_complete_union_member(member_seq_MyUnion, member_string_value); + MemberName name_fourth = "fourth"; + eprosima::fastcdr::optional member_ann_builtin_fourth; + ann_custom_ComplexUnion.reset(); + CompleteMemberDetail detail_fourth = TypeObjectUtils::build_complete_member_detail(name_fourth, member_ann_builtin_fourth, ann_custom_ComplexUnion); + CompleteUnionMember member_fourth = TypeObjectUtils::build_complete_union_member(common_fourth, detail_fourth); + TypeObjectUtils::add_complete_union_member(member_seq_ComplexUnion, member_fourth); } - CompleteUnionType union_type_MyUnion = TypeObjectUtils::build_complete_union_type(union_flags_MyUnion, header_MyUnion, discriminator_MyUnion, - member_seq_MyUnion); + CompleteUnionType union_type_ComplexUnion = TypeObjectUtils::build_complete_union_type(union_flags_ComplexUnion, header_ComplexUnion, discriminator_ComplexUnion, + member_seq_ComplexUnion); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_union_type_object(union_type_MyUnion, type_name_MyUnion.to_string(), type_ids_MyUnion)) + TypeObjectUtils::build_and_register_union_type_object(union_type_ComplexUnion, type_name_ComplexUnion.to_string(), type_ids_ComplexUnion)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "MyUnion already registered in TypeObjectRegistry for a different type."); + "ComplexUnion already registered in TypeObjectRegistry for a different type."); } } } @@ -222,62 +311,60 @@ void register_union_struct_type_identifier( header_union_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_union_struct); CompleteStructMemberSeq member_seq_union_struct; { - TypeIdentifierPair type_ids_index; - ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; - return_code_index = + TypeIdentifierPair type_ids_my_basic_union; + ReturnCode_t return_code_my_basic_union {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_basic_union = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint32_t", type_ids_index); + "BasicUnion", type_ids_my_basic_union); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_union) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; + ::register_BasicUnion_type_identifier(type_ids_my_basic_union); } - StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_basic_union = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_index = 0x00000000; - bool common_index_ec {false}; - CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; - if (!common_index_ec) + MemberId member_id_my_basic_union = 0x00000000; + bool common_my_basic_union_ec {false}; + CommonStructMember common_my_basic_union {TypeObjectUtils::build_common_struct_member(member_id_my_basic_union, member_flags_my_basic_union, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_union, common_my_basic_union_ec))}; + if (!common_my_basic_union_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_union member TypeIdentifier inconsistent."); return; } - MemberName name_index = "index"; - eprosima::fastcdr::optional member_ann_builtin_index; + MemberName name_my_basic_union = "my_basic_union"; + eprosima::fastcdr::optional member_ann_builtin_my_basic_union; ann_custom_union_struct.reset(); - CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_union_struct); - CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); - TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_index); + CompleteMemberDetail detail_my_basic_union = TypeObjectUtils::build_complete_member_detail(name_my_basic_union, member_ann_builtin_my_basic_union, ann_custom_union_struct); + CompleteStructMember member_my_basic_union = TypeObjectUtils::build_complete_struct_member(common_my_basic_union, detail_my_basic_union); + TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_my_basic_union); } { - TypeIdentifierPair type_ids_union_value; - ReturnCode_t return_code_union_value {eprosima::fastdds::dds::RETCODE_OK}; - return_code_union_value = + TypeIdentifierPair type_ids_my_complex_union; + ReturnCode_t return_code_my_complex_union {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_union = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyUnion", type_ids_union_value); + "ComplexUnion", type_ids_my_complex_union); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_union_value) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_union) { - ::register_MyUnion_type_identifier(type_ids_union_value); + ::register_ComplexUnion_type_identifier(type_ids_my_complex_union); } - StructMemberFlag member_flags_union_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_complex_union = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_union_value = 0x00000001; - bool common_union_value_ec {false}; - CommonStructMember common_union_value {TypeObjectUtils::build_common_struct_member(member_id_union_value, member_flags_union_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_union_value, common_union_value_ec))}; - if (!common_union_value_ec) + MemberId member_id_my_complex_union = 0x00000001; + bool common_my_complex_union_ec {false}; + CommonStructMember common_my_complex_union {TypeObjectUtils::build_common_struct_member(member_id_my_complex_union, member_flags_my_complex_union, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_union, common_my_complex_union_ec))}; + if (!common_my_complex_union_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure union_value member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_union member TypeIdentifier inconsistent."); return; } - MemberName name_union_value = "union_value"; - eprosima::fastcdr::optional member_ann_builtin_union_value; + MemberName name_my_complex_union = "my_complex_union"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_union; ann_custom_union_struct.reset(); - CompleteMemberDetail detail_union_value = TypeObjectUtils::build_complete_member_detail(name_union_value, member_ann_builtin_union_value, ann_custom_union_struct); - CompleteStructMember member_union_value = TypeObjectUtils::build_complete_struct_member(common_union_value, detail_union_value); - TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_union_value); + CompleteMemberDetail detail_my_complex_union = TypeObjectUtils::build_complete_member_detail(name_my_complex_union, member_ann_builtin_my_complex_union, ann_custom_union_struct); + CompleteStructMember member_my_complex_union = TypeObjectUtils::build_complete_struct_member(common_my_complex_union, detail_my_complex_union); + TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_my_complex_union); } CompleteStructType struct_type_union_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_union_struct, header_union_struct, member_seq_union_struct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp index 6949f933e1f..506e964366b 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register MyUnion related TypeIdentifier. + * @brief Register BasicUnion related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,7 +47,19 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyUnion_type_identifier( +eProsima_user_DllExport void register_BasicUnion_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register ComplexUnion related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ComplexUnion_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** * @brief Register union_struct related TypeIdentifier. diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl new file mode 100644 index 00000000000..3d0561202ce --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl @@ -0,0 +1,4 @@ +struct map_bounded_struct +{ + map my_map; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl index d4d19acbdec..0f09ef8b587 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl @@ -1,4 +1,10 @@ +struct ValueStruct +{ + boolean value; +}; + struct map_struct { - map my_map; + map my_basic_map; + map my_complex_map; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl new file mode 100644 index 00000000000..0cfb2f03bd9 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl @@ -0,0 +1,11 @@ +struct ColorAmount +{ + long red; + long green; + long blue; +}; + +struct multi_array_struct +{ + ColorAmount colors[5][5][5]; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl new file mode 100644 index 00000000000..5c026cbda7d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl @@ -0,0 +1,7 @@ +struct string_struct +{ + string my_string; + wstring my_wstring; + string<41925> my_bounded_string; + wstring<20925> my_bounded_wstring; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl index 3967f961a41..100bfedded1 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl @@ -1,15 +1,23 @@ -union MyUnion switch (long) +union BasicUnion switch (short) { + case 0: + string first; case 1: - octet octet_value; - case 2: - long long_value; - case 3: - string string_value; + default: + long long second; +}; + +union ComplexUnion switch (long) +{ + case 0: + case 1: + long third; + default: + BasicUnion fourth; }; struct union_struct { - unsigned long index; - MyUnion union_value; + BasicUnion my_basic_union; + ComplexUnion my_complex_union; }; From f8d75abd0f2e441441d26300073880fcaf9e8e74 Mon Sep 17 00:00:00 2001 From: tempate Date: Fri, 5 Jul 2024 13:02:28 +0200 Subject: [PATCH 38/52] Review - Refactor Tests Signed-off-by: tempate --- .../dds/xtypes/serializers/idl/CMakeLists.txt | 86 +- .../serializers/idl/DynTypeIDLTests.cpp | 4 +- .../{idls => alias_struct}/alias_struct.idl | 2 +- .../gen}/alias_struct.hpp | 40 +- .../gen}/alias_structCdrAux.hpp | 6 +- .../gen}/alias_structCdrAux.ipp | 8 +- .../gen}/alias_structPubSubTypes.cxx | 46 +- .../gen}/alias_structPubSubTypes.hpp | 10 +- .../gen}/alias_structTypeObjectSupport.cxx | 52 +- .../gen}/alias_structTypeObjectSupport.hpp | 4 +- .../serializers/idl/types/all_types.hpp | 190 +-- .../idl/types/array_struct/array_struct.idl | 19 + .../types/array_struct/gen/array_struct.hpp | 672 ++++++++++ .../gen/array_structCdrAux.hpp} | 29 +- .../gen/array_structCdrAux.ipp} | 150 ++- .../gen/array_structPubSubTypes.cxx} | 295 +++- .../gen/array_structPubSubTypes.hpp} | 131 +- .../gen/array_structTypeObjectSupport.cxx | 512 +++++++ .../gen/array_structTypeObjectSupport.hpp} | 28 +- .../bitmask_struct.idl | 2 +- .../gen}/bitmask_struct.hpp | 40 +- .../gen}/bitmask_structCdrAux.hpp | 7 +- .../gen}/bitmask_structCdrAux.ipp | 8 +- .../gen}/bitmask_structPubSubTypes.cxx | 46 +- .../gen}/bitmask_structPubSubTypes.hpp | 10 +- .../gen}/bitmask_structTypeObjectSupport.cxx | 40 +- .../gen}/bitmask_structTypeObjectSupport.hpp | 4 +- .../{idls => bitset_struct}/bitset_struct.idl | 2 +- .../gen}/bitset_struct.hpp | 40 +- .../gen}/bitset_structCdrAux.hpp | 6 +- .../gen}/bitset_structCdrAux.ipp | 8 +- .../gen}/bitset_structPubSubTypes.cxx | 46 +- .../gen}/bitset_structPubSubTypes.hpp | 10 +- .../gen}/bitset_structTypeObjectSupport.cxx | 40 +- .../gen}/bitset_structTypeObjectSupport.hpp | 4 +- .../{idls => enum_struct}/enum_struct.idl | 3 +- .../gen}/enum_struct.hpp | 79 +- .../gen}/enum_structCdrAux.hpp | 6 +- .../gen}/enum_structCdrAux.ipp | 18 +- .../gen}/enum_structPubSubTypes.cxx | 46 +- .../gen}/enum_structPubSubTypes.hpp | 10 +- .../gen}/enum_structTypeObjectSupport.cxx | 72 +- .../gen}/enum_structTypeObjectSupport.hpp | 4 +- .../extensibility_struct.idl | 23 + .../gen}/extensibility_struct.hpp | 298 ++-- .../gen}/extensibility_structCdrAux.hpp | 8 +- .../gen}/extensibility_structCdrAux.ipp | 44 +- .../gen}/extensibility_structPubSubTypes.cxx | 46 +- .../gen}/extensibility_structPubSubTypes.hpp | 12 +- .../extensibility_structTypeObjectSupport.cxx | 244 ++-- .../extensibility_structTypeObjectSupport.hpp | 4 +- .../arrays_and_sequences.hpp | 445 ------ .../arrays_and_sequencesPubSubTypes.cxx | 422 ------ .../arrays_and_sequencesPubSubTypes.hpp | 224 ---- .../arrays_and_sequencesTypeObjectSupport.cxx | 341 ----- .../arrays_and_sequencesTypeObjectSupport.hpp | 68 - .../basic_array_struct/basic_array_struct.hpp | 386 ------ .../basic_array_structTypeObjectSupport.cxx | 251 ---- .../types/gen/basic_struct/basic_struct.hpp | 311 ----- .../gen/basic_struct/basic_structCdrAux.hpp | 53 - .../gen/basic_struct/basic_structCdrAux.ipp | 194 --- .../basic_structTypeObjectSupport.cxx | 157 --- .../types/gen/char_sequence/char_sequence.hpp | 190 --- .../gen/char_sequence/char_sequenceCdrAux.hpp | 46 - .../gen/char_sequence/char_sequenceCdrAux.ipp | 118 -- .../char_sequencePubSubTypes.cxx | 229 ---- .../char_sequencePubSubTypes.hpp | 133 -- .../char_sequenceTypeObjectSupport.cxx | 132 -- .../char_sequenceTypeObjectSupport.hpp | 56 - .../complex_nested_arrays.hpp | 760 ----------- ...complex_nested_arraysTypeObjectSupport.cxx | 493 ------- .../float_bounded_sequence.hpp | 190 --- .../float_bounded_sequenceCdrAux.hpp | 46 - .../float_bounded_sequenceCdrAux.ipp | 118 -- .../float_bounded_sequencePubSubTypes.cxx | 229 ---- .../float_bounded_sequencePubSubTypes.hpp | 133 -- ...loat_bounded_sequenceTypeObjectSupport.cxx | 132 -- ...loat_bounded_sequenceTypeObjectSupport.hpp | 56 - .../idl/types/gen/hello_world/hello_world.hpp | 227 ---- .../gen/hello_world/hello_worldCdrAux.hpp | 46 - .../gen/hello_world/hello_worldCdrAux.ipp | 126 -- .../hello_world/hello_worldPubSubTypes.cxx | 229 ---- .../hello_world/hello_worldPubSubTypes.hpp | 133 -- .../hello_worldTypeObjectSupport.cxx | 138 -- .../hello_worldTypeObjectSupport.hpp | 56 - .../inheritance_struct/inheritance_struct.hpp | 843 ------------ .../inheritance_structCdrAux.hpp | 81 -- .../inheritance_structCdrAux.ipp | 618 --------- .../inheritance_structPubSubTypes.cxx | 1194 ----------------- .../inheritance_structPubSubTypes.hpp | 588 -------- .../inheritance_structTypeObjectSupport.cxx | 500 ------- .../inheritance_structTypeObjectSupport.hpp | 116 -- .../idl/types/gen/key_struct/key_struct.hpp | 252 ---- .../types/gen/key_struct/key_structCdrAux.ipp | 138 -- .../gen/key_struct/key_structPubSubTypes.cxx | 229 ---- .../gen/key_struct/key_structPubSubTypes.hpp | 133 -- .../key_structTypeObjectSupport.cxx | 186 --- .../key_structTypeObjectSupport.hpp | 56 - .../map_bounded_struct/map_bounded_struct.hpp | 191 --- .../map_bounded_structCdrAux.hpp | 46 - .../map_bounded_structCdrAux.ipp | 118 -- .../map_bounded_structPubSubTypes.cxx | 229 ---- .../map_bounded_structPubSubTypes.hpp | 133 -- .../map_bounded_structTypeObjectSupport.cxx | 167 --- .../map_bounded_structTypeObjectSupport.hpp | 56 - .../multi_array_struct/multi_array_struct.hpp | 386 ------ .../multi_array_structCdrAux.hpp | 53 - .../multi_array_structTypeObjectSupport.cxx | 255 ---- .../types/gen/nested_struct/nested_struct.hpp | 1031 -------------- .../gen/nested_struct/nested_structCdrAux.hpp | 81 -- .../gen/nested_struct/nested_structCdrAux.ipp | 530 -------- .../nested_structPubSubTypes.cxx | 1194 ----------------- .../nested_structPubSubTypes.hpp | 588 -------- .../nested_structTypeObjectSupport.cxx | 497 ------- .../nested_structTypeObjectSupport.hpp | 116 -- .../types/gen/numeric_array/numeric_array.hpp | 189 --- .../gen/numeric_array/numeric_arrayCdrAux.hpp | 46 - .../gen/numeric_array/numeric_arrayCdrAux.ipp | 118 -- .../numeric_arrayPubSubTypes.cxx | 229 ---- .../numeric_arrayPubSubTypes.hpp | 133 -- .../numeric_arrayTypeObjectSupport.cxx | 134 -- .../numeric_arrayTypeObjectSupport.hpp | 56 - .../idl/types/idls/arrays_and_sequences.idl | 12 - .../idl/types/idls/basic_array_struct.idl | 11 - .../idl/types/idls/basic_struct.idl | 9 - .../idl/types/idls/char_sequence.idl | 4 - .../idl/types/idls/complex_nested_arrays.idl | 23 - .../idl/types/idls/extensibility_struct.idl | 23 - .../idl/types/idls/float_bounded_sequence.idl | 4 - .../idl/types/idls/hello_world.idl | 5 - .../idl/types/idls/inheritance_struct.idl | 29 - .../serializers/idl/types/idls/key_struct.idl | 6 - .../idl/types/idls/map_bounded_struct.idl | 4 - .../idl/types/idls/multi_array_struct.idl | 11 - .../idl/types/idls/nested_struct.idl | 33 - .../idl/types/idls/numeric_array.idl | 4 - .../idl/types/key_struct/gen/key_struct.hpp | 508 +++++++ .../gen}/key_structCdrAux.hpp | 13 +- .../gen/key_structCdrAux.ipp} | 83 +- .../gen/key_structPubSubTypes.cxx} | 106 +- .../gen/key_structPubSubTypes.hpp} | 38 +- .../gen/key_structTypeObjectSupport.cxx | 380 ++++++ .../gen/key_structTypeObjectSupport.hpp} | 16 +- .../idl/types/key_struct/key_struct.idl | 14 + .../gen}/map_struct.hpp | 136 +- .../gen}/map_structCdrAux.hpp | 8 +- .../gen}/map_structCdrAux.ipp | 24 +- .../gen}/map_structPubSubTypes.cxx | 46 +- .../gen}/map_structPubSubTypes.hpp | 10 +- .../gen}/map_structTypeObjectSupport.cxx | 230 +++- .../gen}/map_structTypeObjectSupport.hpp | 4 +- .../types/{idls => map_struct}/map_struct.idl | 4 +- .../sequence_struct/gen/sequence_struct.hpp | 673 ++++++++++ .../gen/sequence_structCdrAux.hpp} | 29 +- .../gen/sequence_structCdrAux.ipp} | 150 ++- .../gen/sequence_structPubSubTypes.cxx} | 295 +++- .../gen/sequence_structPubSubTypes.hpp} | 131 +- .../gen/sequence_structTypeObjectSupport.cxx | 498 +++++++ .../gen/sequence_structTypeObjectSupport.hpp} | 28 +- .../types/sequence_struct/sequence_struct.idl | 19 + .../gen}/string_struct.hpp | 40 +- .../gen}/string_structCdrAux.hpp | 6 +- .../gen}/string_structCdrAux.ipp | 8 +- .../gen}/string_structPubSubTypes.cxx | 46 +- .../gen}/string_structPubSubTypes.hpp | 10 +- .../gen}/string_structTypeObjectSupport.cxx | 58 +- .../gen}/string_structTypeObjectSupport.hpp | 4 +- .../{idls => string_struct}/string_struct.idl | 2 +- .../types/struct_struct/gen/struct_struct.hpp | 663 +++++++++ .../gen/struct_structCdrAux.hpp} | 34 +- .../gen/struct_structCdrAux.ipp} | 136 +- .../gen/struct_structPubSubTypes.cxx} | 194 +-- .../gen/struct_structPubSubTypes.hpp} | 64 +- .../gen/struct_structTypeObjectSupport.cxx | 385 ++++++ .../gen/struct_structTypeObjectSupport.hpp} | 24 +- .../idl/types/struct_struct/struct_struct.idl | 21 + .../gen}/union_struct.hpp | 89 +- .../gen}/union_structCdrAux.hpp | 7 +- .../gen}/union_structCdrAux.ipp | 18 +- .../gen}/union_structPubSubTypes.cxx | 46 +- .../gen}/union_structPubSubTypes.hpp | 10 +- .../gen}/union_structTypeObjectSupport.cxx | 70 +- .../gen}/union_structTypeObjectSupport.hpp | 4 +- .../{idls => union_struct}/union_struct.idl | 3 +- 184 files changed, 7075 insertions(+), 20380 deletions(-) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => alias_struct}/alias_struct.idl (89%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_struct.hpp (84%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structCdrAux.ipp (97%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structPubSubTypes.cxx (83%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structTypeObjectSupport.cxx (90%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/alias_struct => alias_struct/gen}/alias_structTypeObjectSupport.hpp (97%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_struct.hpp rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_array_struct/basic_array_structCdrAux.hpp => array_struct/gen/array_structCdrAux.hpp} (57%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_array_struct/basic_array_structCdrAux.ipp => array_struct/gen/array_structCdrAux.ipp} (53%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/multi_array_struct/multi_array_structPubSubTypes.cxx => array_struct/gen/array_structPubSubTypes.cxx} (54%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/multi_array_struct/multi_array_structPubSubTypes.hpp => array_struct/gen/array_structPubSubTypes.hpp} (60%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.cxx rename test/unittest/dds/xtypes/serializers/idl/types/{gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp => array_struct/gen/array_structTypeObjectSupport.hpp} (66%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => bitmask_struct}/bitmask_struct.idl (86%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_struct.hpp (79%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structCdrAux.ipp (96%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structPubSubTypes.cxx (82%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structTypeObjectSupport.cxx (85%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitmask_struct => bitmask_struct/gen}/bitmask_structTypeObjectSupport.hpp (95%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => bitset_struct}/bitset_struct.idl (89%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_struct.hpp (81%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structCdrAux.ipp (97%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structPubSubTypes.cxx (82%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structTypeObjectSupport.cxx (85%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/bitset_struct => bitset_struct/gen}/bitset_structTypeObjectSupport.hpp (95%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => enum_struct}/enum_struct.idl (64%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_struct.hpp (64%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structCdrAux.ipp (86%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structPubSubTypes.cxx (83%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structTypeObjectSupport.cxx (69%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/enum_struct => enum_struct/gen}/enum_structTypeObjectSupport.hpp (95%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_struct.hpp (51%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structCdrAux.hpp (91%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structCdrAux.ipp (89%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structPubSubTypes.cxx (94%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structPubSubTypes.hpp (96%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structTypeObjectSupport.cxx (54%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/extensibility_struct => extensibility_struct/gen}/extensibility_structTypeObjectSupport.hpp (96%) delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl delete mode 100644 test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_struct.hpp rename test/unittest/dds/xtypes/serializers/idl/types/{gen/key_struct => key_struct/gen}/key_structCdrAux.hpp (75%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp => key_struct/gen/key_structCdrAux.ipp} (70%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_struct/basic_structPubSubTypes.cxx => key_struct/gen/key_structPubSubTypes.cxx} (79%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_struct/basic_structPubSubTypes.hpp => key_struct/gen/key_structPubSubTypes.hpp} (84%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.cxx rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_struct/basic_structTypeObjectSupport.hpp => key_struct/gen/key_structTypeObjectSupport.hpp} (82%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_struct.hpp (63%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structCdrAux.hpp (90%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structCdrAux.ipp (87%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structPubSubTypes.cxx (91%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structPubSubTypes.hpp (95%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structTypeObjectSupport.cxx (56%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/map_struct => map_struct/gen}/map_structTypeObjectSupport.hpp (95%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => map_struct}/map_struct.idl (52%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_struct.hpp rename test/unittest/dds/xtypes/serializers/idl/types/{gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp => sequence_struct/gen/sequence_structCdrAux.hpp} (56%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/multi_array_struct/multi_array_structCdrAux.ipp => sequence_struct/gen/sequence_structCdrAux.ipp} (53%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_array_struct/basic_array_structPubSubTypes.cxx => sequence_struct/gen/sequence_structPubSubTypes.cxx} (54%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_array_struct/basic_array_structPubSubTypes.hpp => sequence_struct/gen/sequence_structPubSubTypes.hpp} (59%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.cxx rename test/unittest/dds/xtypes/serializers/idl/types/{gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp => sequence_struct/gen/sequence_structTypeObjectSupport.hpp} (65%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_struct.hpp (89%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structCdrAux.ipp (97%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structPubSubTypes.cxx (82%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structTypeObjectSupport.cxx (85%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/string_struct => string_struct/gen}/string_structTypeObjectSupport.hpp (94%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => string_struct}/string_struct.idl (85%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp rename test/unittest/dds/xtypes/serializers/idl/types/{gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp => struct_struct/gen/struct_structCdrAux.hpp} (56%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp => struct_struct/gen/struct_structCdrAux.ipp} (77%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx => struct_struct/gen/struct_structPubSubTypes.cxx} (78%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp => struct_struct/gen/struct_structPubSubTypes.hpp} (84%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx rename test/unittest/dds/xtypes/serializers/idl/types/{gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp => struct_struct/gen/struct_structTypeObjectSupport.hpp} (80%) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_struct.hpp (89%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structCdrAux.hpp (88%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structCdrAux.ipp (95%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structPubSubTypes.cxx (83%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structPubSubTypes.hpp (92%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structTypeObjectSupport.cxx (84%) rename test/unittest/dds/xtypes/serializers/idl/types/{gen/union_struct => union_struct/gen}/union_structTypeObjectSupport.hpp (96%) rename test/unittest/dds/xtypes/serializers/idl/types/{idls => union_struct}/union_struct.idl (84%) diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index 075309b11a0..e0ec77e3e15 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -13,95 +13,59 @@ # limitations under the License. configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/alias_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/alias_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/alias_struct/alias_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/alias_struct/alias_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/arrays_and_sequences.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/arrays_and_sequences.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/array_struct/array_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/array_struct/array_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_array_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_array_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/bitmask_struct/bitmask_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/bitmask_struct/bitmask_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/basic_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/basic_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/bitset_struct/bitset_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/bitset_struct/bitset_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitmask_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitmask_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/enum_struct/enum_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/enum_struct/enum_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/bitset_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/bitset_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/extensibility_struct/extensibility_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/extensibility_struct/extensibility_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/char_sequence.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/char_sequence.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/key_struct/key_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/key_struct/key_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/complex_nested_arrays.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/complex_nested_arrays.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/map_struct/map_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/map_struct/map_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/inheritance_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/inheritance_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/sequence_struct/sequence_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/sequence_struct/sequence_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/enum_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/enum_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/string_struct/string_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/string_struct/string_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/extensibility_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/extensibility_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/struct_struct/struct_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/struct_struct/struct_struct.idl COPYONLY) configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/float_bounded_sequence.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/float_bounded_sequence.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/hello_world.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/hello_world.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/key_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/key_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_bounded_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_bounded_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/map_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/map_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/multi_array_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/multi_array_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/nested_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/nested_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/numeric_array.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/numeric_array.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/string_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/string_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/idls/union_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/idls/union_struct.idl + ${CMAKE_CURRENT_SOURCE_DIR}/types/union_struct/union_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/union_struct/union_struct.idl COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynTypeIDLTests.cpp ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/xtypes/utils.cpp) -file(GLOB DATATYPE_SOURCES "types/gen/**/*.cxx") +file(GLOB DATATYPE_SOURCES "types/**/gen/*.cxx") if(WIN32) add_definitions(-D_WIN32_WINNT=0x0601) diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index 6a5ec2f1070..187d12fc424 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -94,7 +94,7 @@ TEST_P(DynTypeIDLTests, to_idl) test::register_type_object_representation(type); // Read the IDL file as a string - const auto file_name = std::string("types/idls/") + type + ".idl"; + const auto file_name = std::string("types/") + type + "/" + type + ".idl"; std::ifstream file(file_name); ASSERT_TRUE(file.is_open()); @@ -103,7 +103,7 @@ TEST_P(DynTypeIDLTests, to_idl) // Get Dynamic type DynamicType::_ref_type dyn_type; - get_dynamic_type(type, dyn_type); + get_dynamic_type(snake_to_camel(type), dyn_type); // Serialize DynamicType to IDL std::stringstream idl_serialization; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/alias_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl similarity index 89% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/alias_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl index 0a0f1d1db71..b30dd6b8049 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/alias_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl @@ -4,7 +4,7 @@ typedef unsigned long MyLong; typedef MyShort MyRecursiveShort; -struct alias_struct +struct AliasStruct { MyShort my_short; MyLong my_long; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp similarity index 84% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp index 7afdd76c685..d267c51b0a1 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp @@ -56,33 +56,33 @@ typedef uint32_t MyLong; typedef MyShort MyRecursiveShort; /*! - * @brief This class represents the structure alias_struct defined by the user in the IDL file. + * @brief This class represents the structure AliasStruct defined by the user in the IDL file. * @ingroup alias_struct */ -class alias_struct +class AliasStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport alias_struct() + eProsima_user_DllExport AliasStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~alias_struct() + eProsima_user_DllExport ~AliasStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object alias_struct that will be copied. + * @param x Reference to the object AliasStruct that will be copied. */ - eProsima_user_DllExport alias_struct( - const alias_struct& x) + eProsima_user_DllExport AliasStruct( + const AliasStruct& x) { m_my_short = x.m_my_short; @@ -94,10 +94,10 @@ class alias_struct /*! * @brief Move constructor. - * @param x Reference to the object alias_struct that will be copied. + * @param x Reference to the object AliasStruct that will be copied. */ - eProsima_user_DllExport alias_struct( - alias_struct&& x) noexcept + eProsima_user_DllExport AliasStruct( + AliasStruct&& x) noexcept { m_my_short = x.m_my_short; m_my_long = x.m_my_long; @@ -106,10 +106,10 @@ class alias_struct /*! * @brief Copy assignment. - * @param x Reference to the object alias_struct that will be copied. + * @param x Reference to the object AliasStruct that will be copied. */ - eProsima_user_DllExport alias_struct& operator =( - const alias_struct& x) + eProsima_user_DllExport AliasStruct& operator =( + const AliasStruct& x) { m_my_short = x.m_my_short; @@ -123,10 +123,10 @@ class alias_struct /*! * @brief Move assignment. - * @param x Reference to the object alias_struct that will be copied. + * @param x Reference to the object AliasStruct that will be copied. */ - eProsima_user_DllExport alias_struct& operator =( - alias_struct&& x) noexcept + eProsima_user_DllExport AliasStruct& operator =( + AliasStruct&& x) noexcept { m_my_short = x.m_my_short; @@ -137,10 +137,10 @@ class alias_struct /*! * @brief Comparison operator. - * @param x alias_struct object to compare. + * @param x AliasStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const alias_struct& x) const + const AliasStruct& x) const { return (m_my_short == x.m_my_short && m_my_long == x.m_my_long && @@ -149,10 +149,10 @@ class alias_struct /*! * @brief Comparison operator. - * @param x alias_struct object to compare. + * @param x AliasStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const alias_struct& x) const + const AliasStruct& x) const { return !(*this == x); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp index 46cc826df1f..1a0316fcf80 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp @@ -24,8 +24,8 @@ #include "alias_struct.hpp" -constexpr uint32_t alias_struct_max_cdr_typesize {14UL}; -constexpr uint32_t alias_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t AliasStruct_max_cdr_typesize {14UL}; +constexpr uint32_t AliasStruct_max_key_cdr_typesize {0UL}; @@ -39,7 +39,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const alias_struct& data); + const AliasStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp similarity index 97% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp index 5094322b724..267fca2ea5f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const alias_struct& data, + const AliasStruct& data, size_t& current_alignment) { static_cast(data); @@ -68,7 +68,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const alias_struct& data) + const AliasStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -87,7 +87,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - alias_struct& data) + AliasStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -119,7 +119,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const alias_struct& data) + const AliasStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.cxx similarity index 83% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.cxx index 04e1a8c24b8..5957e1d7df1 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -alias_structPubSubType::alias_structPubSubType() +AliasStructPubSubType::AliasStructPubSubType() { - setName("alias_struct"); + setName("AliasStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(alias_struct::getMaxCdrSerializedSize()); + static_cast(AliasStruct::getMaxCdrSerializedSize()); #else - alias_struct_max_cdr_typesize; + AliasStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = alias_struct_max_key_cdr_typesize > 16 ? alias_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = AliasStruct_max_key_cdr_typesize > 16 ? AliasStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -alias_structPubSubType::~alias_structPubSubType() +AliasStructPubSubType::~AliasStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ alias_structPubSubType::~alias_structPubSubType() } } -bool alias_structPubSubType::serialize( +bool AliasStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const alias_struct* p_type = static_cast(data); + const AliasStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool alias_structPubSubType::serialize( return true; } -bool alias_structPubSubType::deserialize( +bool AliasStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - alias_struct* p_type = static_cast(data); + AliasStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool alias_structPubSubType::deserialize( return true; } -std::function alias_structPubSubType::getSerializedSizeProvider( +std::function AliasStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function alias_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function alias_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function alias_structPubSubType::getSerializedSizeProvider( }; } -void* alias_structPubSubType::createData() +void* AliasStructPubSubType::createData() { - return reinterpret_cast(new alias_struct()); + return reinterpret_cast(new AliasStruct()); } -void alias_structPubSubType::deleteData( +void AliasStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool alias_structPubSubType::getKey( +bool AliasStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool alias_structPubSubType::getKey( return false; } - const alias_struct* p_type = static_cast(data); + const AliasStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - alias_struct_max_key_cdr_typesize); + AliasStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool alias_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || alias_struct_max_key_cdr_typesize > 16) + if (force_md5 || AliasStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool alias_structPubSubType::getKey( return true; } -void alias_structPubSubType::register_type_object_representation() +void AliasStructPubSubType::register_type_object_representation() { - register_alias_struct_type_identifier(type_identifiers_); + register_AliasStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp index 86e0e6fadfd..74c77cfe142 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp @@ -42,18 +42,18 @@ typedef uint32_t MyLong; typedef MyShort MyRecursiveShort; /*! - * @brief This class represents the TopicDataType of the type alias_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type AliasStruct defined by the user in the IDL file. * @ingroup alias_struct */ -class alias_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class AliasStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef alias_struct type; + typedef AliasStruct type; - eProsima_user_DllExport alias_structPubSubType(); + eProsima_user_DllExport AliasStructPubSubType(); - eProsima_user_DllExport ~alias_structPubSubType() override; + eProsima_user_DllExport ~AliasStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx similarity index 90% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx index 834ef379b04..9729c554eae 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx @@ -187,25 +187,25 @@ void register_MyRecursiveShort_type_identifier( } // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_alias_struct_type_identifier( - TypeIdentifierPair& type_ids_alias_struct) +void register_AliasStruct_type_identifier( + TypeIdentifierPair& type_ids_AliasStruct) { - ReturnCode_t return_code_alias_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_alias_struct = + ReturnCode_t return_code_AliasStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_AliasStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "alias_struct", type_ids_alias_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_alias_struct) + "AliasStruct", type_ids_AliasStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_AliasStruct) { - StructTypeFlag struct_flags_alias_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_AliasStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_alias_struct = "alias_struct"; - eprosima::fastcdr::optional type_ann_builtin_alias_struct; - eprosima::fastcdr::optional ann_custom_alias_struct; - CompleteTypeDetail detail_alias_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_alias_struct, ann_custom_alias_struct, type_name_alias_struct.to_string()); - CompleteStructHeader header_alias_struct; - header_alias_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_alias_struct); - CompleteStructMemberSeq member_seq_alias_struct; + QualifiedTypeName type_name_AliasStruct = "AliasStruct"; + eprosima::fastcdr::optional type_ann_builtin_AliasStruct; + eprosima::fastcdr::optional ann_custom_AliasStruct; + CompleteTypeDetail detail_AliasStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_AliasStruct, ann_custom_AliasStruct, type_name_AliasStruct.to_string()); + CompleteStructHeader header_AliasStruct; + header_AliasStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AliasStruct); + CompleteStructMemberSeq member_seq_AliasStruct; { TypeIdentifierPair type_ids_my_short; ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; @@ -229,10 +229,10 @@ void register_alias_struct_type_identifier( } MemberName name_my_short = "my_short"; eprosima::fastcdr::optional member_ann_builtin_my_short; - ann_custom_alias_struct.reset(); - CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_alias_struct); + ann_custom_AliasStruct.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_AliasStruct); CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); - TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_short); } { TypeIdentifierPair type_ids_my_long; @@ -257,10 +257,10 @@ void register_alias_struct_type_identifier( } MemberName name_my_long = "my_long"; eprosima::fastcdr::optional member_ann_builtin_my_long; - ann_custom_alias_struct.reset(); - CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_alias_struct); + ann_custom_AliasStruct.reset(); + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_AliasStruct); CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); - TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_long); } { TypeIdentifierPair type_ids_my_recursive_short; @@ -285,17 +285,17 @@ void register_alias_struct_type_identifier( } MemberName name_my_recursive_short = "my_recursive_short"; eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; - ann_custom_alias_struct.reset(); - CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_alias_struct); + ann_custom_AliasStruct.reset(); + CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_AliasStruct); CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); - TypeObjectUtils::add_complete_struct_member(member_seq_alias_struct, member_my_recursive_short); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); } - CompleteStructType struct_type_alias_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_alias_struct, header_alias_struct, member_seq_alias_struct); + CompleteStructType struct_type_AliasStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AliasStruct, header_AliasStruct, member_seq_AliasStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_alias_struct, type_name_alias_struct.to_string(), type_ids_alias_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_AliasStruct, type_name_AliasStruct.to_string(), type_ids_AliasStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "alias_struct already registered in TypeObjectRegistry for a different type."); + "AliasStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp similarity index 97% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp index acb6fd3d1a5..82de769e185 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/alias_struct/alias_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp @@ -80,7 +80,7 @@ eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( /** - * @brief Register alias_struct related TypeIdentifier. + * @brief Register AliasStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -89,7 +89,7 @@ eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_alias_struct_type_identifier( +eProsima_user_DllExport void register_AliasStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp index 91aa7a99b9a..520c3b6b1cc 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp @@ -20,118 +20,73 @@ #include -#include "gen/alias_struct/alias_struct.hpp" -#include "gen/alias_struct/alias_structPubSubTypes.hpp" +#include "alias_struct/gen/alias_struct.hpp" +#include "alias_struct/gen/alias_structPubSubTypes.hpp" -#include "gen/arrays_and_sequences/arrays_and_sequences.hpp" -#include "gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp" +#include "array_struct/gen/array_struct.hpp" +#include "array_struct/gen/array_structPubSubTypes.hpp" -#include "gen/basic_array_struct/basic_array_struct.hpp" -#include "gen/basic_array_struct/basic_array_structPubSubTypes.hpp" +#include "bitmask_struct/gen/bitmask_struct.hpp" +#include "bitmask_struct/gen/bitmask_structPubSubTypes.hpp" -#include "gen/basic_struct/basic_struct.hpp" -#include "gen/basic_struct/basic_structPubSubTypes.hpp" +#include "bitset_struct/gen/bitset_struct.hpp" +#include "bitset_struct/gen/bitset_structPubSubTypes.hpp" -#include "gen/bitmask_struct/bitmask_struct.hpp" -#include "gen/bitmask_struct/bitmask_structPubSubTypes.hpp" +#include "enum_struct/gen/enum_struct.hpp" +#include "enum_struct/gen/enum_structPubSubTypes.hpp" -#include "gen/bitset_struct/bitset_struct.hpp" -#include "gen/bitset_struct/bitset_structPubSubTypes.hpp" +#include "extensibility_struct/gen/extensibility_struct.hpp" +#include "extensibility_struct/gen/extensibility_structPubSubTypes.hpp" -#include "gen/char_sequence/char_sequence.hpp" -#include "gen/char_sequence/char_sequencePubSubTypes.hpp" +#include "key_struct/gen/key_struct.hpp" +#include "key_struct/gen/key_structPubSubTypes.hpp" -#include "gen/complex_nested_arrays/complex_nested_arrays.hpp" -#include "gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp" +#include "map_struct/gen/map_struct.hpp" +#include "map_struct/gen/map_structPubSubTypes.hpp" -#include "gen/enum_struct/enum_struct.hpp" -#include "gen/enum_struct/enum_structPubSubTypes.hpp" +#include "sequence_struct/gen/sequence_struct.hpp" +#include "sequence_struct/gen/sequence_structPubSubTypes.hpp" -#include "gen/extensibility_struct/extensibility_struct.hpp" -#include "gen/extensibility_struct/extensibility_structPubSubTypes.hpp" +#include "string_struct/gen/string_struct.hpp" +#include "string_struct/gen/string_structPubSubTypes.hpp" -#include "gen/float_bounded_sequence/float_bounded_sequence.hpp" -#include "gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp" +#include "struct_struct/gen/struct_struct.hpp" +#include "struct_struct/gen/struct_structPubSubTypes.hpp" -#include "gen/hello_world/hello_world.hpp" -#include "gen/hello_world/hello_worldPubSubTypes.hpp" - -#include "gen/inheritance_struct/inheritance_struct.hpp" -#include "gen/inheritance_struct/inheritance_structPubSubTypes.hpp" - -#include "gen/key_struct/key_struct.hpp" -#include "gen/key_struct/key_structPubSubTypes.hpp" - -#include "gen/map_bounded_struct/map_bounded_struct.hpp" -#include "gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp" - -#include "gen/map_struct/map_struct.hpp" -#include "gen/map_struct/map_structPubSubTypes.hpp" - -#include "gen/multi_array_struct/multi_array_struct.hpp" -#include "gen/multi_array_struct/multi_array_structPubSubTypes.hpp" - -#include "gen/nested_struct/nested_struct.hpp" -#include "gen/nested_struct/nested_structPubSubTypes.hpp" - -#include "gen/numeric_array/numeric_array.hpp" -#include "gen/numeric_array/numeric_arrayPubSubTypes.hpp" - -#include "gen/string_struct/string_struct.hpp" -#include "gen/string_struct/string_structPubSubTypes.hpp" - -#include "gen/union_struct/union_struct.hpp" -#include "gen/union_struct/union_structPubSubTypes.hpp" +#include "union_struct/gen/union_struct.hpp" +#include "union_struct/gen/union_structPubSubTypes.hpp" namespace test { namespace SupportedTypes { const std::string ALIAS_STRUCT{"alias_struct"}; -const std::string ARRAYS_AND_SEQUENCES{"arrays_and_sequences"}; -const std::string BASIC_ARRAY_STRUCT{"basic_array_struct"}; -const std::string BASIC_STRUCT{"basic_struct"}; +const std::string ARRAY_STRUCT{"array_struct"}; const std::string BITMASK_STRUCT{"bitmask_struct"}; const std::string BITSET_STRUCT{"bitset_struct"}; -const std::string CHAR_SEQUENCE{"char_sequence"}; -const std::string COMPLEX_NESTED_ARRAYS{"complex_nested_arrays"}; const std::string ENUM_STRUCT{"enum_struct"}; const std::string EXTENSIBILITY_STRUCT{"extensibility_struct"}; -const std::string FLOAT_BOUNDED_SEQUENCE{"float_bounded_sequence"}; -const std::string HELLO_WORLD{"hello_world"}; -const std::string INHERITANCE_STRUCT{"inheritance_struct"}; const std::string KEY_STRUCT{"key_struct"}; -const std::string MAP_BOUNDED_STRUCT{"map_bounded_struct"}; const std::string MAP_STRUCT{"map_struct"}; -const std::string MULTI_ARRAY_STRUCT{"multi_array_struct"}; -const std::string NESTED_STRUCT{"nested_struct"}; -const std::string NUMERIC_ARRAY{"numeric_array"}; +const std::string SEQUENCE_STRUCT{"sequence_struct"}; const std::string STRING_STRUCT{"string_struct"}; +const std::string STRUCT_STRUCT{"struct_struct"}; const std::string UNION_STRUCT{"union_struct"}; } // namespace SupportedTypes const std::vector supported_types = { SupportedTypes::ALIAS_STRUCT, - SupportedTypes::ARRAYS_AND_SEQUENCES, - SupportedTypes::BASIC_ARRAY_STRUCT, - SupportedTypes::BASIC_STRUCT, + SupportedTypes::ARRAY_STRUCT, SupportedTypes::BITMASK_STRUCT, SupportedTypes::BITSET_STRUCT, - SupportedTypes::CHAR_SEQUENCE, - SupportedTypes::COMPLEX_NESTED_ARRAYS, SupportedTypes::ENUM_STRUCT, SupportedTypes::EXTENSIBILITY_STRUCT, - SupportedTypes::FLOAT_BOUNDED_SEQUENCE, - SupportedTypes::HELLO_WORLD, - SupportedTypes::INHERITANCE_STRUCT, SupportedTypes::KEY_STRUCT, - SupportedTypes::MAP_BOUNDED_STRUCT, SupportedTypes::MAP_STRUCT, - SupportedTypes::MULTI_ARRAY_STRUCT, - SupportedTypes::NESTED_STRUCT, - SupportedTypes::NUMERIC_ARRAY, + SupportedTypes::SEQUENCE_STRUCT, SupportedTypes::STRING_STRUCT, + SupportedTypes::STRUCT_STRUCT, SupportedTypes::UNION_STRUCT }; @@ -142,107 +97,62 @@ void register_type_object_representation( if (type_name == SupportedTypes::ALIAS_STRUCT) { - TypeSupport type_alias_struct(new alias_structPubSubType()); + TypeSupport type_alias_struct(new AliasStructPubSubType()); type_alias_struct->register_type_object_representation(); } - else if (type_name == SupportedTypes::ARRAYS_AND_SEQUENCES) - { - TypeSupport type_arrays_and_sequences(new arrays_and_sequencesPubSubType()); - type_arrays_and_sequences->register_type_object_representation(); - } - else if (type_name == SupportedTypes::BASIC_ARRAY_STRUCT) - { - TypeSupport type_basic_array_struct(new basic_array_structPubSubType()); - type_basic_array_struct->register_type_object_representation(); - } - else if (type_name == SupportedTypes::BASIC_STRUCT) + else if (type_name == SupportedTypes::ARRAY_STRUCT) { - TypeSupport type_basic_struct(new basic_structPubSubType()); - type_basic_struct->register_type_object_representation(); + TypeSupport type_array_struct(new ArrayStructPubSubType()); + type_array_struct->register_type_object_representation(); } else if (type_name == SupportedTypes::BITMASK_STRUCT) { - TypeSupport type_bitmask_struct(new bitmask_structPubSubType()); + TypeSupport type_bitmask_struct(new BitmaskStructPubSubType()); type_bitmask_struct->register_type_object_representation(); } else if (type_name == SupportedTypes::BITSET_STRUCT) { - TypeSupport type_bitset_struct(new bitset_structPubSubType()); + TypeSupport type_bitset_struct(new BitsetStructPubSubType()); type_bitset_struct->register_type_object_representation(); } - else if (type_name == SupportedTypes::CHAR_SEQUENCE) - { - TypeSupport type_char_sequence(new char_sequencePubSubType()); - type_char_sequence->register_type_object_representation(); - } - else if (type_name == SupportedTypes::COMPLEX_NESTED_ARRAYS) - { - TypeSupport type_complex_nested_arrays(new complex_nested_arraysPubSubType()); - type_complex_nested_arrays->register_type_object_representation(); - } else if (type_name == SupportedTypes::ENUM_STRUCT) { - TypeSupport type_enum_struct(new enum_structPubSubType()); + TypeSupport type_enum_struct(new EnumStructPubSubType()); type_enum_struct->register_type_object_representation(); } else if (type_name == SupportedTypes::EXTENSIBILITY_STRUCT) { - TypeSupport type_extensibility_struct(new extensibility_structPubSubType()); + TypeSupport type_extensibility_struct(new ExtensibilityStructPubSubType()); type_extensibility_struct->register_type_object_representation(); } - else if (type_name == SupportedTypes::FLOAT_BOUNDED_SEQUENCE) - { - TypeSupport type_float_bounded_sequence(new float_bounded_sequencePubSubType()); - type_float_bounded_sequence->register_type_object_representation(); - } - else if (type_name == SupportedTypes::HELLO_WORLD) - { - TypeSupport type_hello_world(new hello_worldPubSubType()); - type_hello_world->register_type_object_representation(); - } - else if (type_name == SupportedTypes::INHERITANCE_STRUCT) - { - TypeSupport type_inheritance_struct(new inheritance_structPubSubType()); - type_inheritance_struct->register_type_object_representation(); - } else if (type_name == SupportedTypes::KEY_STRUCT) { - TypeSupport type_key_struct(new key_structPubSubType()); + TypeSupport type_key_struct(new KeyStructPubSubType()); type_key_struct->register_type_object_representation(); } - else if (type_name == SupportedTypes::MAP_BOUNDED_STRUCT) - { - TypeSupport type_map_bounded_struct(new map_bounded_structPubSubType()); - type_map_bounded_struct->register_type_object_representation(); - } else if (type_name == SupportedTypes::MAP_STRUCT) { - TypeSupport type_map_struct(new map_structPubSubType()); + TypeSupport type_map_struct(new MapStructPubSubType()); type_map_struct->register_type_object_representation(); } - else if (type_name == SupportedTypes::MULTI_ARRAY_STRUCT) - { - TypeSupport type_multi_array_struct(new multi_array_structPubSubType()); - type_multi_array_struct->register_type_object_representation(); - } - else if (type_name == SupportedTypes::NESTED_STRUCT) + else if (type_name == SupportedTypes::SEQUENCE_STRUCT) { - TypeSupport type_nested_struct(new nested_structPubSubType()); - type_nested_struct->register_type_object_representation(); - } - else if (type_name == SupportedTypes::NUMERIC_ARRAY) - { - TypeSupport type_numeric_array(new numeric_arrayPubSubType()); - type_numeric_array->register_type_object_representation(); + TypeSupport type_sequence_struct(new SequenceStructPubSubType()); + type_sequence_struct->register_type_object_representation(); } else if (type_name == SupportedTypes::STRING_STRUCT) { - TypeSupport type_string_struct(new string_structPubSubType()); + TypeSupport type_string_struct(new StringStructPubSubType()); type_string_struct->register_type_object_representation(); } + else if (type_name == SupportedTypes::STRUCT_STRUCT) + { + TypeSupport type_struct_struct(new StructStructPubSubType()); + type_struct_struct->register_type_object_representation(); + } else if (type_name == SupportedTypes::UNION_STRUCT) { - TypeSupport type_union_struct(new union_structPubSubType()); + TypeSupport type_union_struct(new UnionStructPubSubType()); type_union_struct->register_type_object_representation(); } else diff --git a/test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl new file mode 100644 index 00000000000..34e24973ed8 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl @@ -0,0 +1,19 @@ +struct NestedArrayElement +{ + string my_string; +}; + +struct ComplexArrayElement +{ + long my_number; + boolean my_boolean; + NestedArrayElement my_nested_element; +}; + +struct ArrayStruct +{ + long my_basic_array[10]; + long my_multidimensional_array[10][10][10]; + ComplexArrayElement my_complex_array[10]; + ComplexArrayElement my_multidimensional_complex_array[10][10]; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_struct.hpp new file mode 100644 index 00000000000..bb946a48bdc --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_struct.hpp @@ -0,0 +1,672 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file array_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__ARRAY_STRUCT_HPP +#define FAST_DDS_GENERATED__ARRAY_STRUCT_HPP + +#include +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(ARRAY_STRUCT_SOURCE) +#define ARRAY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define ARRAY_STRUCT_DllAPI __declspec( dllimport ) +#endif // ARRAY_STRUCT_SOURCE +#else +#define ARRAY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define ARRAY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure NestedArrayElement defined by the user in the IDL file. + * @ingroup array_struct + */ +class NestedArrayElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport NestedArrayElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~NestedArrayElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object NestedArrayElement that will be copied. + */ + eProsima_user_DllExport NestedArrayElement( + const NestedArrayElement& x) + { + m_my_string = x.m_my_string; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object NestedArrayElement that will be copied. + */ + eProsima_user_DllExport NestedArrayElement( + NestedArrayElement&& x) noexcept + { + m_my_string = std::move(x.m_my_string); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object NestedArrayElement that will be copied. + */ + eProsima_user_DllExport NestedArrayElement& operator =( + const NestedArrayElement& x) + { + + m_my_string = x.m_my_string; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object NestedArrayElement that will be copied. + */ + eProsima_user_DllExport NestedArrayElement& operator =( + NestedArrayElement&& x) noexcept + { + + m_my_string = std::move(x.m_my_string); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x NestedArrayElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const NestedArrayElement& x) const + { + return (m_my_string == x.m_my_string); + } + + /*! + * @brief Comparison operator. + * @param x NestedArrayElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const NestedArrayElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_string + * @param _my_string New value to be copied in member my_string + */ + eProsima_user_DllExport void my_string( + const std::string& _my_string) + { + m_my_string = _my_string; + } + + /*! + * @brief This function moves the value in member my_string + * @param _my_string New value to be moved in member my_string + */ + eProsima_user_DllExport void my_string( + std::string&& _my_string) + { + m_my_string = std::move(_my_string); + } + + /*! + * @brief This function returns a constant reference to member my_string + * @return Constant reference to member my_string + */ + eProsima_user_DllExport const std::string& my_string() const + { + return m_my_string; + } + + /*! + * @brief This function returns a reference to member my_string + * @return Reference to member my_string + */ + eProsima_user_DllExport std::string& my_string() + { + return m_my_string; + } + + + +private: + + std::string m_my_string; + +}; +/*! + * @brief This class represents the structure ComplexArrayElement defined by the user in the IDL file. + * @ingroup array_struct + */ +class ComplexArrayElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ComplexArrayElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ComplexArrayElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ComplexArrayElement that will be copied. + */ + eProsima_user_DllExport ComplexArrayElement( + const ComplexArrayElement& x) + { + m_my_number = x.m_my_number; + + m_my_boolean = x.m_my_boolean; + + m_my_nested_element = x.m_my_nested_element; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ComplexArrayElement that will be copied. + */ + eProsima_user_DllExport ComplexArrayElement( + ComplexArrayElement&& x) noexcept + { + m_my_number = x.m_my_number; + m_my_boolean = x.m_my_boolean; + m_my_nested_element = std::move(x.m_my_nested_element); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ComplexArrayElement that will be copied. + */ + eProsima_user_DllExport ComplexArrayElement& operator =( + const ComplexArrayElement& x) + { + + m_my_number = x.m_my_number; + + m_my_boolean = x.m_my_boolean; + + m_my_nested_element = x.m_my_nested_element; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ComplexArrayElement that will be copied. + */ + eProsima_user_DllExport ComplexArrayElement& operator =( + ComplexArrayElement&& x) noexcept + { + + m_my_number = x.m_my_number; + m_my_boolean = x.m_my_boolean; + m_my_nested_element = std::move(x.m_my_nested_element); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ComplexArrayElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ComplexArrayElement& x) const + { + return (m_my_number == x.m_my_number && + m_my_boolean == x.m_my_boolean && + m_my_nested_element == x.m_my_nested_element); + } + + /*! + * @brief Comparison operator. + * @param x ComplexArrayElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ComplexArrayElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_number + * @param _my_number New value for member my_number + */ + eProsima_user_DllExport void my_number( + int32_t _my_number) + { + m_my_number = _my_number; + } + + /*! + * @brief This function returns the value of member my_number + * @return Value of member my_number + */ + eProsima_user_DllExport int32_t my_number() const + { + return m_my_number; + } + + /*! + * @brief This function returns a reference to member my_number + * @return Reference to member my_number + */ + eProsima_user_DllExport int32_t& my_number() + { + return m_my_number; + } + + + /*! + * @brief This function sets a value in member my_boolean + * @param _my_boolean New value for member my_boolean + */ + eProsima_user_DllExport void my_boolean( + bool _my_boolean) + { + m_my_boolean = _my_boolean; + } + + /*! + * @brief This function returns the value of member my_boolean + * @return Value of member my_boolean + */ + eProsima_user_DllExport bool my_boolean() const + { + return m_my_boolean; + } + + /*! + * @brief This function returns a reference to member my_boolean + * @return Reference to member my_boolean + */ + eProsima_user_DllExport bool& my_boolean() + { + return m_my_boolean; + } + + + /*! + * @brief This function copies the value in member my_nested_element + * @param _my_nested_element New value to be copied in member my_nested_element + */ + eProsima_user_DllExport void my_nested_element( + const NestedArrayElement& _my_nested_element) + { + m_my_nested_element = _my_nested_element; + } + + /*! + * @brief This function moves the value in member my_nested_element + * @param _my_nested_element New value to be moved in member my_nested_element + */ + eProsima_user_DllExport void my_nested_element( + NestedArrayElement&& _my_nested_element) + { + m_my_nested_element = std::move(_my_nested_element); + } + + /*! + * @brief This function returns a constant reference to member my_nested_element + * @return Constant reference to member my_nested_element + */ + eProsima_user_DllExport const NestedArrayElement& my_nested_element() const + { + return m_my_nested_element; + } + + /*! + * @brief This function returns a reference to member my_nested_element + * @return Reference to member my_nested_element + */ + eProsima_user_DllExport NestedArrayElement& my_nested_element() + { + return m_my_nested_element; + } + + + +private: + + int32_t m_my_number{0}; + bool m_my_boolean{false}; + NestedArrayElement m_my_nested_element; + +}; +/*! + * @brief This class represents the structure ArrayStruct defined by the user in the IDL file. + * @ingroup array_struct + */ +class ArrayStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ArrayStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ArrayStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ArrayStruct that will be copied. + */ + eProsima_user_DllExport ArrayStruct( + const ArrayStruct& x) + { + m_my_basic_array = x.m_my_basic_array; + + m_my_multidimensional_array = x.m_my_multidimensional_array; + + m_my_complex_array = x.m_my_complex_array; + + m_my_multidimensional_complex_array = x.m_my_multidimensional_complex_array; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ArrayStruct that will be copied. + */ + eProsima_user_DllExport ArrayStruct( + ArrayStruct&& x) noexcept + { + m_my_basic_array = std::move(x.m_my_basic_array); + m_my_multidimensional_array = std::move(x.m_my_multidimensional_array); + m_my_complex_array = std::move(x.m_my_complex_array); + m_my_multidimensional_complex_array = std::move(x.m_my_multidimensional_complex_array); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ArrayStruct that will be copied. + */ + eProsima_user_DllExport ArrayStruct& operator =( + const ArrayStruct& x) + { + + m_my_basic_array = x.m_my_basic_array; + + m_my_multidimensional_array = x.m_my_multidimensional_array; + + m_my_complex_array = x.m_my_complex_array; + + m_my_multidimensional_complex_array = x.m_my_multidimensional_complex_array; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ArrayStruct that will be copied. + */ + eProsima_user_DllExport ArrayStruct& operator =( + ArrayStruct&& x) noexcept + { + + m_my_basic_array = std::move(x.m_my_basic_array); + m_my_multidimensional_array = std::move(x.m_my_multidimensional_array); + m_my_complex_array = std::move(x.m_my_complex_array); + m_my_multidimensional_complex_array = std::move(x.m_my_multidimensional_complex_array); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ArrayStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ArrayStruct& x) const + { + return (m_my_basic_array == x.m_my_basic_array && + m_my_multidimensional_array == x.m_my_multidimensional_array && + m_my_complex_array == x.m_my_complex_array && + m_my_multidimensional_complex_array == x.m_my_multidimensional_complex_array); + } + + /*! + * @brief Comparison operator. + * @param x ArrayStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ArrayStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_basic_array + * @param _my_basic_array New value to be copied in member my_basic_array + */ + eProsima_user_DllExport void my_basic_array( + const std::array& _my_basic_array) + { + m_my_basic_array = _my_basic_array; + } + + /*! + * @brief This function moves the value in member my_basic_array + * @param _my_basic_array New value to be moved in member my_basic_array + */ + eProsima_user_DllExport void my_basic_array( + std::array&& _my_basic_array) + { + m_my_basic_array = std::move(_my_basic_array); + } + + /*! + * @brief This function returns a constant reference to member my_basic_array + * @return Constant reference to member my_basic_array + */ + eProsima_user_DllExport const std::array& my_basic_array() const + { + return m_my_basic_array; + } + + /*! + * @brief This function returns a reference to member my_basic_array + * @return Reference to member my_basic_array + */ + eProsima_user_DllExport std::array& my_basic_array() + { + return m_my_basic_array; + } + + + /*! + * @brief This function copies the value in member my_multidimensional_array + * @param _my_multidimensional_array New value to be copied in member my_multidimensional_array + */ + eProsima_user_DllExport void my_multidimensional_array( + const std::array, 10>, 10>& _my_multidimensional_array) + { + m_my_multidimensional_array = _my_multidimensional_array; + } + + /*! + * @brief This function moves the value in member my_multidimensional_array + * @param _my_multidimensional_array New value to be moved in member my_multidimensional_array + */ + eProsima_user_DllExport void my_multidimensional_array( + std::array, 10>, 10>&& _my_multidimensional_array) + { + m_my_multidimensional_array = std::move(_my_multidimensional_array); + } + + /*! + * @brief This function returns a constant reference to member my_multidimensional_array + * @return Constant reference to member my_multidimensional_array + */ + eProsima_user_DllExport const std::array, 10>, 10>& my_multidimensional_array() const + { + return m_my_multidimensional_array; + } + + /*! + * @brief This function returns a reference to member my_multidimensional_array + * @return Reference to member my_multidimensional_array + */ + eProsima_user_DllExport std::array, 10>, 10>& my_multidimensional_array() + { + return m_my_multidimensional_array; + } + + + /*! + * @brief This function copies the value in member my_complex_array + * @param _my_complex_array New value to be copied in member my_complex_array + */ + eProsima_user_DllExport void my_complex_array( + const std::array& _my_complex_array) + { + m_my_complex_array = _my_complex_array; + } + + /*! + * @brief This function moves the value in member my_complex_array + * @param _my_complex_array New value to be moved in member my_complex_array + */ + eProsima_user_DllExport void my_complex_array( + std::array&& _my_complex_array) + { + m_my_complex_array = std::move(_my_complex_array); + } + + /*! + * @brief This function returns a constant reference to member my_complex_array + * @return Constant reference to member my_complex_array + */ + eProsima_user_DllExport const std::array& my_complex_array() const + { + return m_my_complex_array; + } + + /*! + * @brief This function returns a reference to member my_complex_array + * @return Reference to member my_complex_array + */ + eProsima_user_DllExport std::array& my_complex_array() + { + return m_my_complex_array; + } + + + /*! + * @brief This function copies the value in member my_multidimensional_complex_array + * @param _my_multidimensional_complex_array New value to be copied in member my_multidimensional_complex_array + */ + eProsima_user_DllExport void my_multidimensional_complex_array( + const std::array, 10>& _my_multidimensional_complex_array) + { + m_my_multidimensional_complex_array = _my_multidimensional_complex_array; + } + + /*! + * @brief This function moves the value in member my_multidimensional_complex_array + * @param _my_multidimensional_complex_array New value to be moved in member my_multidimensional_complex_array + */ + eProsima_user_DllExport void my_multidimensional_complex_array( + std::array, 10>&& _my_multidimensional_complex_array) + { + m_my_multidimensional_complex_array = std::move(_my_multidimensional_complex_array); + } + + /*! + * @brief This function returns a constant reference to member my_multidimensional_complex_array + * @return Constant reference to member my_multidimensional_complex_array + */ + eProsima_user_DllExport const std::array, 10>& my_multidimensional_complex_array() const + { + return m_my_multidimensional_complex_array; + } + + /*! + * @brief This function returns a reference to member my_multidimensional_complex_array + * @return Reference to member my_multidimensional_complex_array + */ + eProsima_user_DllExport std::array, 10>& my_multidimensional_complex_array() + { + return m_my_multidimensional_complex_array; + } + + + +private: + + std::array m_my_basic_array{0}; + std::array, 10>, 10> m_my_multidimensional_array{ {{ {{0}} }} }; + std::array m_my_complex_array; + std::array, 10> m_my_multidimensional_complex_array; + +}; + +#endif // _FAST_DDS_GENERATED_ARRAY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.hpp similarity index 57% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.hpp index 3bbf1a9a2a7..2635950d60d 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.hpp @@ -13,22 +13,25 @@ // limitations under the License. /*! - * @file basic_array_structCdrAux.hpp + * @file array_structCdrAux.hpp * This source file contains some definitions of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP +#ifndef FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_HPP -#include "basic_array_struct.hpp" +#include "array_struct.hpp" -constexpr uint32_t basic_array_struct_max_cdr_typesize {69UL}; -constexpr uint32_t basic_array_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t NestedArrayElement_max_cdr_typesize {264UL}; +constexpr uint32_t NestedArrayElement_max_key_cdr_typesize {0UL}; -constexpr uint32_t TheOtherObjectInArray_max_cdr_typesize {9UL}; -constexpr uint32_t TheOtherObjectInArray_max_key_cdr_typesize {0UL}; +constexpr uint32_t ArrayStruct_max_cdr_typesize {34412UL}; +constexpr uint32_t ArrayStruct_max_key_cdr_typesize {0UL}; + +constexpr uint32_t ComplexArrayElement_max_cdr_typesize {276UL}; +constexpr uint32_t ComplexArrayElement_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -39,15 +42,19 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const TheOtherObjectInArray& data); + const NestedArrayElement& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ComplexArrayElement& data); eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const basic_array_struct& data); + const ArrayStruct& data); } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_HPP +#endif // FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.ipp similarity index 53% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.ipp index ebd5483e40b..31c4a5014f1 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structCdrAux.ipp @@ -13,16 +13,16 @@ // limitations under the License. /*! - * @file basic_array_structCdrAux.ipp + * @file array_structCdrAux.ipp * This source file contains some declarations of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP +#ifndef FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_IPP -#include "basic_array_structCdrAux.hpp" +#include "array_structCdrAux.hpp" #include #include @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const TheOtherObjectInArray& data, + const NestedArrayElement& data, size_t& current_alignment) { static_cast(data); @@ -51,10 +51,89 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.some_num(), current_alignment); + data.my_string(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const NestedArrayElement& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_string() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + NestedArrayElement& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_string(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const NestedArrayElement& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ComplexArrayElement& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_number(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.positive(), current_alignment); + data.my_boolean(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_nested_element(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -65,7 +144,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const TheOtherObjectInArray& data) + const ComplexArrayElement& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -74,8 +153,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.some_num() - << eprosima::fastcdr::MemberId(1) << data.positive() + << eprosima::fastcdr::MemberId(0) << data.my_number() + << eprosima::fastcdr::MemberId(1) << data.my_boolean() + << eprosima::fastcdr::MemberId(2) << data.my_nested_element() ; scdr.end_serialize_type(current_state); } @@ -83,7 +163,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - TheOtherObjectInArray& data) + ComplexArrayElement& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -94,11 +174,15 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.some_num(); + dcdr >> data.my_number(); break; case 1: - dcdr >> data.positive(); + dcdr >> data.my_boolean(); + break; + + case 2: + dcdr >> data.my_nested_element(); break; default: @@ -111,7 +195,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const TheOtherObjectInArray& data) + const ComplexArrayElement& data) { static_cast(scdr); static_cast(data); @@ -121,7 +205,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const basic_array_struct& data, + const ArrayStruct& data, size_t& current_alignment) { static_cast(data); @@ -135,10 +219,16 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.index(), current_alignment); + data.my_basic_array(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.sub_structs(), current_alignment); + data.my_multidimensional_array(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_complex_array(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_multidimensional_complex_array(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -149,7 +239,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const basic_array_struct& data) + const ArrayStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -158,8 +248,10 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.index() - << eprosima::fastcdr::MemberId(1) << data.sub_structs() + << eprosima::fastcdr::MemberId(0) << data.my_basic_array() + << eprosima::fastcdr::MemberId(1) << data.my_multidimensional_array() + << eprosima::fastcdr::MemberId(2) << data.my_complex_array() + << eprosima::fastcdr::MemberId(3) << data.my_multidimensional_complex_array() ; scdr.end_serialize_type(current_state); } @@ -167,7 +259,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - basic_array_struct& data) + ArrayStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -178,11 +270,19 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.index(); + dcdr >> data.my_basic_array(); break; case 1: - dcdr >> data.sub_structs(); + dcdr >> data.my_multidimensional_array(); + break; + + case 2: + dcdr >> data.my_complex_array(); + break; + + case 3: + dcdr >> data.my_multidimensional_complex_array(); break; default: @@ -195,7 +295,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const basic_array_struct& data) + const ArrayStruct& data) { static_cast(scdr); static_cast(data); @@ -206,5 +306,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCTCDRAUX_IPP +#endif // FAST_DDS_GENERATED__ARRAY_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.cxx similarity index 54% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.cxx index 94c1c990483..21aa3f8ab17 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.cxx @@ -13,42 +13,42 @@ // limitations under the License. /*! - * @file multi_array_structPubSubTypes.cpp + * @file array_structPubSubTypes.cpp * This header file contains the implementation of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#include "multi_array_structPubSubTypes.hpp" +#include "array_structPubSubTypes.hpp" #include #include -#include "multi_array_structCdrAux.hpp" -#include "multi_array_structTypeObjectSupport.hpp" +#include "array_structCdrAux.hpp" +#include "array_structTypeObjectSupport.hpp" using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -ColorAmountPubSubType::ColorAmountPubSubType() +NestedArrayElementPubSubType::NestedArrayElementPubSubType() { - setName("ColorAmount"); + setName("NestedArrayElement"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(ColorAmount::getMaxCdrSerializedSize()); + static_cast(NestedArrayElement::getMaxCdrSerializedSize()); #else - ColorAmount_max_cdr_typesize; + NestedArrayElement_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = ColorAmount_max_key_cdr_typesize > 16 ? ColorAmount_max_key_cdr_typesize : 16; + uint32_t keyLength = NestedArrayElement_max_key_cdr_typesize > 16 ? NestedArrayElement_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -ColorAmountPubSubType::~ColorAmountPubSubType() +NestedArrayElementPubSubType::~NestedArrayElementPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ ColorAmountPubSubType::~ColorAmountPubSubType() } } -bool ColorAmountPubSubType::serialize( +bool NestedArrayElementPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const ColorAmount* p_type = static_cast(data); + const NestedArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool ColorAmountPubSubType::serialize( return true; } -bool ColorAmountPubSubType::deserialize( +bool NestedArrayElementPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - ColorAmount* p_type = static_cast(data); + NestedArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool ColorAmountPubSubType::deserialize( return true; } -std::function ColorAmountPubSubType::getSerializedSizeProvider( +std::function NestedArrayElementPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function ColorAmountPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function ColorAmountPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function ColorAmountPubSubType::getSerializedSizeProvider( }; } -void* ColorAmountPubSubType::createData() +void* NestedArrayElementPubSubType::createData() { - return reinterpret_cast(new ColorAmount()); + return reinterpret_cast(new NestedArrayElement()); } -void ColorAmountPubSubType::deleteData( +void NestedArrayElementPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool ColorAmountPubSubType::getKey( +bool NestedArrayElementPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool ColorAmountPubSubType::getKey( return false; } - const ColorAmount* p_type = static_cast(data); + const NestedArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - ColorAmount_max_key_cdr_typesize); + NestedArrayElement_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool ColorAmountPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || ColorAmount_max_key_cdr_typesize > 16) + if (force_md5 || NestedArrayElement_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,29 +219,29 @@ bool ColorAmountPubSubType::getKey( return true; } -void ColorAmountPubSubType::register_type_object_representation() +void NestedArrayElementPubSubType::register_type_object_representation() { - register_ColorAmount_type_identifier(type_identifiers_); + register_NestedArrayElement_type_identifier(type_identifiers_); } -multi_array_structPubSubType::multi_array_structPubSubType() +ComplexArrayElementPubSubType::ComplexArrayElementPubSubType() { - setName("multi_array_struct"); + setName("ComplexArrayElement"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(multi_array_struct::getMaxCdrSerializedSize()); + static_cast(ComplexArrayElement::getMaxCdrSerializedSize()); #else - multi_array_struct_max_cdr_typesize; + ComplexArrayElement_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = multi_array_struct_max_key_cdr_typesize > 16 ? multi_array_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = ComplexArrayElement_max_key_cdr_typesize > 16 ? ComplexArrayElement_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -multi_array_structPubSubType::~multi_array_structPubSubType() +ComplexArrayElementPubSubType::~ComplexArrayElementPubSubType() { if (m_keyBuffer != nullptr) { @@ -249,12 +249,12 @@ multi_array_structPubSubType::~multi_array_structPubSubType() } } -bool multi_array_structPubSubType::serialize( +bool ComplexArrayElementPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const multi_array_struct* p_type = static_cast(data); + const ComplexArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -291,14 +291,14 @@ bool multi_array_structPubSubType::serialize( return true; } -bool multi_array_structPubSubType::deserialize( +bool ComplexArrayElementPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - multi_array_struct* p_type = static_cast(data); + ComplexArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -325,7 +325,7 @@ bool multi_array_structPubSubType::deserialize( return true; } -std::function multi_array_structPubSubType::getSerializedSizeProvider( +std::function ComplexArrayElementPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -333,7 +333,7 @@ std::function multi_array_structPubSubType::getSerializedSizeProvide { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -343,7 +343,7 @@ std::function multi_array_structPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -354,18 +354,18 @@ std::function multi_array_structPubSubType::getSerializedSizeProvide }; } -void* multi_array_structPubSubType::createData() +void* ComplexArrayElementPubSubType::createData() { - return reinterpret_cast(new multi_array_struct()); + return reinterpret_cast(new ComplexArrayElement()); } -void multi_array_structPubSubType::deleteData( +void ComplexArrayElementPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool multi_array_structPubSubType::getKey( +bool ComplexArrayElementPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -375,11 +375,11 @@ bool multi_array_structPubSubType::getKey( return false; } - const multi_array_struct* p_type = static_cast(data); + const ComplexArrayElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - multi_array_struct_max_key_cdr_typesize); + ComplexArrayElement_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -388,7 +388,7 @@ bool multi_array_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || multi_array_struct_max_key_cdr_typesize > 16) + if (force_md5 || ComplexArrayElement_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -412,11 +412,204 @@ bool multi_array_structPubSubType::getKey( return true; } -void multi_array_structPubSubType::register_type_object_representation() +void ComplexArrayElementPubSubType::register_type_object_representation() { - register_multi_array_struct_type_identifier(type_identifiers_); + register_ComplexArrayElement_type_identifier(type_identifiers_); +} + +ArrayStructPubSubType::ArrayStructPubSubType() +{ + setName("ArrayStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(ArrayStruct::getMaxCdrSerializedSize()); +#else + ArrayStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = ArrayStruct_max_key_cdr_typesize > 16 ? ArrayStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +ArrayStructPubSubType::~ArrayStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool ArrayStructPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const ArrayStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool ArrayStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + ArrayStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function ArrayStructPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* ArrayStructPubSubType::createData() +{ + return reinterpret_cast(new ArrayStruct()); +} + +void ArrayStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool ArrayStructPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const ArrayStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + ArrayStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || ArrayStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void ArrayStructPubSubType::register_type_object_representation() +{ + register_ArrayStruct_type_identifier(type_identifiers_); } // Include auxiliary functions like for serializing/deserializing. -#include "multi_array_structCdrAux.ipp" +#include "array_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.hpp similarity index 60% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.hpp index 0adcfa1fa6a..0d0672b8fc1 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structPubSubTypes.hpp @@ -13,15 +13,15 @@ // limitations under the License. /*! - * @file multi_array_structPubSubTypes.hpp + * @file array_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP +#ifndef FAST_DDS_GENERATED__ARRAY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__ARRAY_STRUCT_PUBSUBTYPES_HPP #include #include @@ -29,28 +29,28 @@ #include #include -#include "multi_array_struct.hpp" +#include "array_struct.hpp" #if !defined(GEN_API_VER) || (GEN_API_VER != 2) #error \ - Generated multi_array_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. + Generated array_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // GEN_API_VER /*! - * @brief This class represents the TopicDataType of the type ColorAmount defined by the user in the IDL file. - * @ingroup multi_array_struct + * @brief This class represents the TopicDataType of the type NestedArrayElement defined by the user in the IDL file. + * @ingroup array_struct */ -class ColorAmountPubSubType : public eprosima::fastdds::dds::TopicDataType +class NestedArrayElementPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef ColorAmount type; + typedef NestedArrayElement type; - eProsima_user_DllExport ColorAmountPubSubType(); + eProsima_user_DllExport NestedArrayElementPubSubType(); - eProsima_user_DllExport ~ColorAmountPubSubType() override; + eProsima_user_DllExport ~NestedArrayElementPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -94,7 +94,7 @@ class ColorAmountPubSubType : public eprosima::fastdds::dds::TopicDataType #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -130,18 +130,18 @@ class ColorAmountPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type multi_array_struct defined by the user in the IDL file. - * @ingroup multi_array_struct + * @brief This class represents the TopicDataType of the type ComplexArrayElement defined by the user in the IDL file. + * @ingroup array_struct */ -class multi_array_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class ComplexArrayElementPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef multi_array_struct type; + typedef ComplexArrayElement type; - eProsima_user_DllExport multi_array_structPubSubType(); + eProsima_user_DllExport ComplexArrayElementPubSubType(); - eProsima_user_DllExport ~multi_array_structPubSubType() override; + eProsima_user_DllExport ~ComplexArrayElementPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -185,7 +185,98 @@ class multi_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type ArrayStruct defined by the user in the IDL file. + * @ingroup array_struct + */ +class ArrayStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef ArrayStruct type; + + eProsima_user_DllExport ArrayStructPubSubType(); + + eProsima_user_DllExport ~ArrayStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -220,5 +311,5 @@ class multi_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp }; -#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_PUBSUBTYPES_HPP +#endif // FAST_DDS_GENERATED__ARRAY_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..3296426196d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.cxx @@ -0,0 +1,512 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file array_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "array_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "array_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_NestedArrayElement_type_identifier( + TypeIdentifierPair& type_ids_NestedArrayElement) +{ + + ReturnCode_t return_code_NestedArrayElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_NestedArrayElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedArrayElement", type_ids_NestedArrayElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_NestedArrayElement) + { + StructTypeFlag struct_flags_NestedArrayElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_NestedArrayElement = "NestedArrayElement"; + eprosima::fastcdr::optional type_ann_builtin_NestedArrayElement; + eprosima::fastcdr::optional ann_custom_NestedArrayElement; + CompleteTypeDetail detail_NestedArrayElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_NestedArrayElement, ann_custom_NestedArrayElement, type_name_NestedArrayElement.to_string()); + CompleteStructHeader header_NestedArrayElement; + header_NestedArrayElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_NestedArrayElement); + CompleteStructMemberSeq member_seq_NestedArrayElement; + { + TypeIdentifierPair type_ids_my_string; + ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_string) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_string = 0x00000000; + bool common_my_string_ec {false}; + CommonStructMember common_my_string {TypeObjectUtils::build_common_struct_member(member_id_my_string, member_flags_my_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_string, common_my_string_ec))}; + if (!common_my_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_string = "my_string"; + eprosima::fastcdr::optional member_ann_builtin_my_string; + ann_custom_NestedArrayElement.reset(); + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_NestedArrayElement); + CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_NestedArrayElement, member_my_string); + } + CompleteStructType struct_type_NestedArrayElement = TypeObjectUtils::build_complete_struct_type(struct_flags_NestedArrayElement, header_NestedArrayElement, member_seq_NestedArrayElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_NestedArrayElement, type_name_NestedArrayElement.to_string(), type_ids_NestedArrayElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "NestedArrayElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ComplexArrayElement_type_identifier( + TypeIdentifierPair& type_ids_ComplexArrayElement) +{ + + ReturnCode_t return_code_ComplexArrayElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ComplexArrayElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexArrayElement", type_ids_ComplexArrayElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ComplexArrayElement) + { + StructTypeFlag struct_flags_ComplexArrayElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ComplexArrayElement = "ComplexArrayElement"; + eprosima::fastcdr::optional type_ann_builtin_ComplexArrayElement; + eprosima::fastcdr::optional ann_custom_ComplexArrayElement; + CompleteTypeDetail detail_ComplexArrayElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ComplexArrayElement, ann_custom_ComplexArrayElement, type_name_ComplexArrayElement.to_string()); + CompleteStructHeader header_ComplexArrayElement; + header_ComplexArrayElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ComplexArrayElement); + CompleteStructMemberSeq member_seq_ComplexArrayElement; + { + TypeIdentifierPair type_ids_my_number; + ReturnCode_t return_code_my_number {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_number = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_number); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_number) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_number Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_number = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_number = 0x00000000; + bool common_my_number_ec {false}; + CommonStructMember common_my_number {TypeObjectUtils::build_common_struct_member(member_id_my_number, member_flags_my_number, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_number, common_my_number_ec))}; + if (!common_my_number_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_number member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_number = "my_number"; + eprosima::fastcdr::optional member_ann_builtin_my_number; + ann_custom_ComplexArrayElement.reset(); + CompleteMemberDetail detail_my_number = TypeObjectUtils::build_complete_member_detail(name_my_number, member_ann_builtin_my_number, ann_custom_ComplexArrayElement); + CompleteStructMember member_my_number = TypeObjectUtils::build_complete_struct_member(common_my_number, detail_my_number); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexArrayElement, member_my_number); + } + { + TypeIdentifierPair type_ids_my_boolean; + ReturnCode_t return_code_my_boolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_boolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_my_boolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_boolean) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_boolean Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_boolean = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_boolean = 0x00000001; + bool common_my_boolean_ec {false}; + CommonStructMember common_my_boolean {TypeObjectUtils::build_common_struct_member(member_id_my_boolean, member_flags_my_boolean, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_boolean, common_my_boolean_ec))}; + if (!common_my_boolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_boolean member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_boolean = "my_boolean"; + eprosima::fastcdr::optional member_ann_builtin_my_boolean; + ann_custom_ComplexArrayElement.reset(); + CompleteMemberDetail detail_my_boolean = TypeObjectUtils::build_complete_member_detail(name_my_boolean, member_ann_builtin_my_boolean, ann_custom_ComplexArrayElement); + CompleteStructMember member_my_boolean = TypeObjectUtils::build_complete_struct_member(common_my_boolean, detail_my_boolean); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexArrayElement, member_my_boolean); + } + { + TypeIdentifierPair type_ids_my_nested_element; + ReturnCode_t return_code_my_nested_element {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_nested_element = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedArrayElement", type_ids_my_nested_element); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_nested_element) + { + ::register_NestedArrayElement_type_identifier(type_ids_my_nested_element); + } + StructMemberFlag member_flags_my_nested_element = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_nested_element = 0x00000002; + bool common_my_nested_element_ec {false}; + CommonStructMember common_my_nested_element {TypeObjectUtils::build_common_struct_member(member_id_my_nested_element, member_flags_my_nested_element, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_nested_element, common_my_nested_element_ec))}; + if (!common_my_nested_element_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_nested_element member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_nested_element = "my_nested_element"; + eprosima::fastcdr::optional member_ann_builtin_my_nested_element; + ann_custom_ComplexArrayElement.reset(); + CompleteMemberDetail detail_my_nested_element = TypeObjectUtils::build_complete_member_detail(name_my_nested_element, member_ann_builtin_my_nested_element, ann_custom_ComplexArrayElement); + CompleteStructMember member_my_nested_element = TypeObjectUtils::build_complete_struct_member(common_my_nested_element, detail_my_nested_element); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexArrayElement, member_my_nested_element); + } + CompleteStructType struct_type_ComplexArrayElement = TypeObjectUtils::build_complete_struct_type(struct_flags_ComplexArrayElement, header_ComplexArrayElement, member_seq_ComplexArrayElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ComplexArrayElement, type_name_ComplexArrayElement.to_string(), type_ids_ComplexArrayElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ComplexArrayElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ArrayStruct_type_identifier( + TypeIdentifierPair& type_ids_ArrayStruct) +{ + + ReturnCode_t return_code_ArrayStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ArrayStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ArrayStruct", type_ids_ArrayStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ArrayStruct) + { + StructTypeFlag struct_flags_ArrayStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ArrayStruct = "ArrayStruct"; + eprosima::fastcdr::optional type_ann_builtin_ArrayStruct; + eprosima::fastcdr::optional ann_custom_ArrayStruct; + CompleteTypeDetail detail_ArrayStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ArrayStruct, ann_custom_ArrayStruct, type_name_ArrayStruct.to_string()); + CompleteStructHeader header_ArrayStruct; + header_ArrayStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ArrayStruct); + CompleteStructMemberSeq member_seq_ArrayStruct; + { + TypeIdentifierPair type_ids_my_basic_array; + ReturnCode_t return_code_my_basic_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_basic_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_int32_t_10", type_ids_my_basic_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_array) + { + return_code_my_basic_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_basic_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_array) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Array element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_array_int32_t_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_int32_t_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_array, element_identifier_anonymous_array_int32_t_10_ec))}; + if (!element_identifier_anonymous_array_int32_t_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_int32_t_10 = EK_COMPLETE; + if (TK_NONE == type_ids_my_basic_array.type_identifier2()._d()) + { + equiv_kind_anonymous_array_int32_t_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_int32_t_10 = 0; + PlainCollectionHeader header_anonymous_array_int32_t_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_int32_t_10, element_flags_anonymous_array_int32_t_10); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_int32_t_10, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_int32_t_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_int32_t_10", type_ids_my_basic_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_int32_t_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_basic_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_basic_array = 0x00000000; + bool common_my_basic_array_ec {false}; + CommonStructMember common_my_basic_array {TypeObjectUtils::build_common_struct_member(member_id_my_basic_array, member_flags_my_basic_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_array, common_my_basic_array_ec))}; + if (!common_my_basic_array_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_array member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_basic_array = "my_basic_array"; + eprosima::fastcdr::optional member_ann_builtin_my_basic_array; + ann_custom_ArrayStruct.reset(); + CompleteMemberDetail detail_my_basic_array = TypeObjectUtils::build_complete_member_detail(name_my_basic_array, member_ann_builtin_my_basic_array, ann_custom_ArrayStruct); + CompleteStructMember member_my_basic_array = TypeObjectUtils::build_complete_struct_member(common_my_basic_array, detail_my_basic_array); + TypeObjectUtils::add_complete_struct_member(member_seq_ArrayStruct, member_my_basic_array); + } + { + TypeIdentifierPair type_ids_my_multidimensional_array; + ReturnCode_t return_code_my_multidimensional_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_multidimensional_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_int32_t_10_10_10", type_ids_my_multidimensional_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_multidimensional_array) + { + return_code_my_multidimensional_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_multidimensional_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_multidimensional_array) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Array element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_array_int32_t_10_10_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_int32_t_10_10_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_multidimensional_array, element_identifier_anonymous_array_int32_t_10_10_10_ec))}; + if (!element_identifier_anonymous_array_int32_t_10_10_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_int32_t_10_10_10 = EK_COMPLETE; + if (TK_NONE == type_ids_my_multidimensional_array.type_identifier2()._d()) + { + equiv_kind_anonymous_array_int32_t_10_10_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_int32_t_10_10_10 = 0; + PlainCollectionHeader header_anonymous_array_int32_t_10_10_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_int32_t_10_10_10, element_flags_anonymous_array_int32_t_10_10_10); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_int32_t_10_10_10, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_int32_t_10_10_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_int32_t_10_10_10", type_ids_my_multidimensional_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_int32_t_10_10_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_multidimensional_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_multidimensional_array = 0x00000001; + bool common_my_multidimensional_array_ec {false}; + CommonStructMember common_my_multidimensional_array {TypeObjectUtils::build_common_struct_member(member_id_my_multidimensional_array, member_flags_my_multidimensional_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_multidimensional_array, common_my_multidimensional_array_ec))}; + if (!common_my_multidimensional_array_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_multidimensional_array member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_multidimensional_array = "my_multidimensional_array"; + eprosima::fastcdr::optional member_ann_builtin_my_multidimensional_array; + ann_custom_ArrayStruct.reset(); + CompleteMemberDetail detail_my_multidimensional_array = TypeObjectUtils::build_complete_member_detail(name_my_multidimensional_array, member_ann_builtin_my_multidimensional_array, ann_custom_ArrayStruct); + CompleteStructMember member_my_multidimensional_array = TypeObjectUtils::build_complete_struct_member(common_my_multidimensional_array, detail_my_multidimensional_array); + TypeObjectUtils::add_complete_struct_member(member_seq_ArrayStruct, member_my_multidimensional_array); + } + { + TypeIdentifierPair type_ids_my_complex_array; + ReturnCode_t return_code_my_complex_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_ComplexArrayElement_10", type_ids_my_complex_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_array) + { + return_code_my_complex_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexArrayElement", type_ids_my_complex_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_array) + { + ::register_ComplexArrayElement_type_identifier(type_ids_my_complex_array); + } + bool element_identifier_anonymous_array_ComplexArrayElement_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_ComplexArrayElement_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_array, element_identifier_anonymous_array_ComplexArrayElement_10_ec))}; + if (!element_identifier_anonymous_array_ComplexArrayElement_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_ComplexArrayElement_10 = EK_COMPLETE; + if (TK_NONE == type_ids_my_complex_array.type_identifier2()._d()) + { + equiv_kind_anonymous_array_ComplexArrayElement_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_ComplexArrayElement_10 = 0; + PlainCollectionHeader header_anonymous_array_ComplexArrayElement_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_ComplexArrayElement_10, element_flags_anonymous_array_ComplexArrayElement_10); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_ComplexArrayElement_10, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_ComplexArrayElement_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_ComplexArrayElement_10", type_ids_my_complex_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_ComplexArrayElement_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_complex_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_complex_array = 0x00000002; + bool common_my_complex_array_ec {false}; + CommonStructMember common_my_complex_array {TypeObjectUtils::build_common_struct_member(member_id_my_complex_array, member_flags_my_complex_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_array, common_my_complex_array_ec))}; + if (!common_my_complex_array_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_array member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_complex_array = "my_complex_array"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_array; + ann_custom_ArrayStruct.reset(); + CompleteMemberDetail detail_my_complex_array = TypeObjectUtils::build_complete_member_detail(name_my_complex_array, member_ann_builtin_my_complex_array, ann_custom_ArrayStruct); + CompleteStructMember member_my_complex_array = TypeObjectUtils::build_complete_struct_member(common_my_complex_array, detail_my_complex_array); + TypeObjectUtils::add_complete_struct_member(member_seq_ArrayStruct, member_my_complex_array); + } + { + TypeIdentifierPair type_ids_my_multidimensional_complex_array; + ReturnCode_t return_code_my_multidimensional_complex_array {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_multidimensional_complex_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_array_ComplexArrayElement_10_10", type_ids_my_multidimensional_complex_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_multidimensional_complex_array) + { + return_code_my_multidimensional_complex_array = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexArrayElement", type_ids_my_multidimensional_complex_array); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_multidimensional_complex_array) + { + ::register_ComplexArrayElement_type_identifier(type_ids_my_multidimensional_complex_array); + } + bool element_identifier_anonymous_array_ComplexArrayElement_10_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_array_ComplexArrayElement_10_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_multidimensional_complex_array, element_identifier_anonymous_array_ComplexArrayElement_10_10_ec))}; + if (!element_identifier_anonymous_array_ComplexArrayElement_10_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_array_ComplexArrayElement_10_10 = EK_COMPLETE; + if (TK_NONE == type_ids_my_multidimensional_complex_array.type_identifier2()._d()) + { + equiv_kind_anonymous_array_ComplexArrayElement_10_10 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_array_ComplexArrayElement_10_10 = 0; + PlainCollectionHeader header_anonymous_array_ComplexArrayElement_10_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_ComplexArrayElement_10_10, element_flags_anonymous_array_ComplexArrayElement_10_10); + { + SBoundSeq array_bound_seq; + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); + + PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_ComplexArrayElement_10_10, array_bound_seq, + eprosima::fastcdr::external(element_identifier_anonymous_array_ComplexArrayElement_10_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_ComplexArrayElement_10_10", type_ids_my_multidimensional_complex_array)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_array_ComplexArrayElement_10_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_multidimensional_complex_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_multidimensional_complex_array = 0x00000003; + bool common_my_multidimensional_complex_array_ec {false}; + CommonStructMember common_my_multidimensional_complex_array {TypeObjectUtils::build_common_struct_member(member_id_my_multidimensional_complex_array, member_flags_my_multidimensional_complex_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_multidimensional_complex_array, common_my_multidimensional_complex_array_ec))}; + if (!common_my_multidimensional_complex_array_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_multidimensional_complex_array member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_multidimensional_complex_array = "my_multidimensional_complex_array"; + eprosima::fastcdr::optional member_ann_builtin_my_multidimensional_complex_array; + ann_custom_ArrayStruct.reset(); + CompleteMemberDetail detail_my_multidimensional_complex_array = TypeObjectUtils::build_complete_member_detail(name_my_multidimensional_complex_array, member_ann_builtin_my_multidimensional_complex_array, ann_custom_ArrayStruct); + CompleteStructMember member_my_multidimensional_complex_array = TypeObjectUtils::build_complete_struct_member(common_my_multidimensional_complex_array, detail_my_multidimensional_complex_array); + TypeObjectUtils::add_complete_struct_member(member_seq_ArrayStruct, member_my_multidimensional_complex_array); + } + CompleteStructType struct_type_ArrayStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ArrayStruct, header_ArrayStruct, member_seq_ArrayStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ArrayStruct, type_name_ArrayStruct.to_string(), type_ids_ArrayStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ArrayStruct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.hpp similarity index 66% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.hpp index 93bb42861d5..1677b876be7 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/array_struct/gen/array_structTypeObjectSupport.hpp @@ -13,14 +13,14 @@ // limitations under the License. /*! - * @file multi_array_structTypeObjectSupport.hpp + * @file array_structTypeObjectSupport.hpp * Header file containing the API required to register the TypeObject representation of the described types in the IDL file * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#ifndef FAST_DDS_GENERATED__ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register ColorAmount related TypeIdentifier. + * @brief Register NestedArrayElement related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,10 +47,10 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_ColorAmount_type_identifier( +eProsima_user_DllExport void register_NestedArrayElement_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register multi_array_struct related TypeIdentifier. + * @brief Register ComplexArrayElement related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,10 +59,22 @@ eProsima_user_DllExport void register_ColorAmount_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_multi_array_struct_type_identifier( +eProsima_user_DllExport void register_ComplexArrayElement_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register ArrayStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_ArrayStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#endif // FAST_DDS_GENERATED__ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/bitmask_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl similarity index 86% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/bitmask_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl index 02afbaa323f..2d6cd006c79 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/bitmask_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl @@ -7,7 +7,7 @@ bitmask ColorBitmask @position(5) yellow }; -struct bitmask_struct +struct BitmaskStruct { ColorBitmask my_bitmask; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_struct.hpp similarity index 79% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_struct.hpp index cd015d0d19d..83ee6c64fc2 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_struct.hpp @@ -62,33 +62,33 @@ enum ColorBitmaskBits : uint8_t }; typedef uint8_t ColorBitmask; /*! - * @brief This class represents the structure bitmask_struct defined by the user in the IDL file. + * @brief This class represents the structure BitmaskStruct defined by the user in the IDL file. * @ingroup bitmask_struct */ -class bitmask_struct +class BitmaskStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport bitmask_struct() + eProsima_user_DllExport BitmaskStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~bitmask_struct() + eProsima_user_DllExport ~BitmaskStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object bitmask_struct that will be copied. + * @param x Reference to the object BitmaskStruct that will be copied. */ - eProsima_user_DllExport bitmask_struct( - const bitmask_struct& x) + eProsima_user_DllExport BitmaskStruct( + const BitmaskStruct& x) { m_my_bitmask = x.m_my_bitmask; @@ -96,20 +96,20 @@ class bitmask_struct /*! * @brief Move constructor. - * @param x Reference to the object bitmask_struct that will be copied. + * @param x Reference to the object BitmaskStruct that will be copied. */ - eProsima_user_DllExport bitmask_struct( - bitmask_struct&& x) noexcept + eProsima_user_DllExport BitmaskStruct( + BitmaskStruct&& x) noexcept { m_my_bitmask = std::move(x.m_my_bitmask); } /*! * @brief Copy assignment. - * @param x Reference to the object bitmask_struct that will be copied. + * @param x Reference to the object BitmaskStruct that will be copied. */ - eProsima_user_DllExport bitmask_struct& operator =( - const bitmask_struct& x) + eProsima_user_DllExport BitmaskStruct& operator =( + const BitmaskStruct& x) { m_my_bitmask = x.m_my_bitmask; @@ -119,10 +119,10 @@ class bitmask_struct /*! * @brief Move assignment. - * @param x Reference to the object bitmask_struct that will be copied. + * @param x Reference to the object BitmaskStruct that will be copied. */ - eProsima_user_DllExport bitmask_struct& operator =( - bitmask_struct&& x) noexcept + eProsima_user_DllExport BitmaskStruct& operator =( + BitmaskStruct&& x) noexcept { m_my_bitmask = std::move(x.m_my_bitmask); @@ -131,20 +131,20 @@ class bitmask_struct /*! * @brief Comparison operator. - * @param x bitmask_struct object to compare. + * @param x BitmaskStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const bitmask_struct& x) const + const BitmaskStruct& x) const { return (m_my_bitmask == x.m_my_bitmask); } /*! * @brief Comparison operator. - * @param x bitmask_struct object to compare. + * @param x BitmaskStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const bitmask_struct& x) const + const BitmaskStruct& x) const { return !(*this == x); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.hpp index 78cf5b1751f..20178cc24bc 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.hpp @@ -24,9 +24,8 @@ #include "bitmask_struct.hpp" -constexpr uint32_t bitmask_struct_max_cdr_typesize {5UL}; -constexpr uint32_t bitmask_struct_max_key_cdr_typesize {0UL}; - +constexpr uint32_t BitmaskStruct_max_cdr_typesize {5UL}; +constexpr uint32_t BitmaskStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -37,7 +36,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const bitmask_struct& data); + const BitmaskStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.ipp similarity index 96% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.ipp index 125ea1044a8..e8b6c9e5e61 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structCdrAux.ipp @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const bitmask_struct& data, + const BitmaskStruct& data, size_t& current_alignment) { static_cast(data); @@ -62,7 +62,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const bitmask_struct& data) + const BitmaskStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -79,7 +79,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - bitmask_struct& data) + BitmaskStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -103,7 +103,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const bitmask_struct& data) + const BitmaskStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.cxx similarity index 82% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.cxx index c0f391078b6..a42af45f42c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -bitmask_structPubSubType::bitmask_structPubSubType() +BitmaskStructPubSubType::BitmaskStructPubSubType() { - setName("bitmask_struct"); + setName("BitmaskStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(bitmask_struct::getMaxCdrSerializedSize()); + static_cast(BitmaskStruct::getMaxCdrSerializedSize()); #else - bitmask_struct_max_cdr_typesize; + BitmaskStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = bitmask_struct_max_key_cdr_typesize > 16 ? bitmask_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = BitmaskStruct_max_key_cdr_typesize > 16 ? BitmaskStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -bitmask_structPubSubType::~bitmask_structPubSubType() +BitmaskStructPubSubType::~BitmaskStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ bitmask_structPubSubType::~bitmask_structPubSubType() } } -bool bitmask_structPubSubType::serialize( +bool BitmaskStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const bitmask_struct* p_type = static_cast(data); + const BitmaskStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool bitmask_structPubSubType::serialize( return true; } -bool bitmask_structPubSubType::deserialize( +bool BitmaskStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - bitmask_struct* p_type = static_cast(data); + BitmaskStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool bitmask_structPubSubType::deserialize( return true; } -std::function bitmask_structPubSubType::getSerializedSizeProvider( +std::function BitmaskStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function bitmask_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function bitmask_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function bitmask_structPubSubType::getSerializedSizeProvider( }; } -void* bitmask_structPubSubType::createData() +void* BitmaskStructPubSubType::createData() { - return reinterpret_cast(new bitmask_struct()); + return reinterpret_cast(new BitmaskStruct()); } -void bitmask_structPubSubType::deleteData( +void BitmaskStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool bitmask_structPubSubType::getKey( +bool BitmaskStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool bitmask_structPubSubType::getKey( return false; } - const bitmask_struct* p_type = static_cast(data); + const BitmaskStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - bitmask_struct_max_key_cdr_typesize); + BitmaskStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool bitmask_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || bitmask_struct_max_key_cdr_typesize > 16) + if (force_md5 || BitmaskStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool bitmask_structPubSubType::getKey( return true; } -void bitmask_structPubSubType::register_type_object_representation() +void BitmaskStructPubSubType::register_type_object_representation() { - register_bitmask_struct_type_identifier(type_identifiers_); + register_BitmaskStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.hpp index 1687d0a15ea..df42d2f96aa 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structPubSubTypes.hpp @@ -39,18 +39,18 @@ /*! - * @brief This class represents the TopicDataType of the type bitmask_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type BitmaskStruct defined by the user in the IDL file. * @ingroup bitmask_struct */ -class bitmask_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class BitmaskStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef bitmask_struct type; + typedef BitmaskStruct type; - eProsima_user_DllExport bitmask_structPubSubType(); + eProsima_user_DllExport BitmaskStructPubSubType(); - eProsima_user_DllExport ~bitmask_structPubSubType() override; + eProsima_user_DllExport ~BitmaskStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.cxx similarity index 85% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.cxx index b4bb192c816..08699ae6d97 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.cxx @@ -127,25 +127,25 @@ void register_ColorBitmask_type_identifier( } } }// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_bitmask_struct_type_identifier( - TypeIdentifierPair& type_ids_bitmask_struct) +void register_BitmaskStruct_type_identifier( + TypeIdentifierPair& type_ids_BitmaskStruct) { - ReturnCode_t return_code_bitmask_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_bitmask_struct = + ReturnCode_t return_code_BitmaskStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_BitmaskStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "bitmask_struct", type_ids_bitmask_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_bitmask_struct) + "BitmaskStruct", type_ids_BitmaskStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_BitmaskStruct) { - StructTypeFlag struct_flags_bitmask_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_BitmaskStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_bitmask_struct = "bitmask_struct"; - eprosima::fastcdr::optional type_ann_builtin_bitmask_struct; - eprosima::fastcdr::optional ann_custom_bitmask_struct; - CompleteTypeDetail detail_bitmask_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_bitmask_struct, ann_custom_bitmask_struct, type_name_bitmask_struct.to_string()); - CompleteStructHeader header_bitmask_struct; - header_bitmask_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_bitmask_struct); - CompleteStructMemberSeq member_seq_bitmask_struct; + QualifiedTypeName type_name_BitmaskStruct = "BitmaskStruct"; + eprosima::fastcdr::optional type_ann_builtin_BitmaskStruct; + eprosima::fastcdr::optional ann_custom_BitmaskStruct; + CompleteTypeDetail detail_BitmaskStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BitmaskStruct, ann_custom_BitmaskStruct, type_name_BitmaskStruct.to_string()); + CompleteStructHeader header_BitmaskStruct; + header_BitmaskStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BitmaskStruct); + CompleteStructMemberSeq member_seq_BitmaskStruct; { TypeIdentifierPair type_ids_my_bitmask; ReturnCode_t return_code_my_bitmask {eprosima::fastdds::dds::RETCODE_OK}; @@ -169,17 +169,17 @@ void register_bitmask_struct_type_identifier( } MemberName name_my_bitmask = "my_bitmask"; eprosima::fastcdr::optional member_ann_builtin_my_bitmask; - ann_custom_bitmask_struct.reset(); - CompleteMemberDetail detail_my_bitmask = TypeObjectUtils::build_complete_member_detail(name_my_bitmask, member_ann_builtin_my_bitmask, ann_custom_bitmask_struct); + ann_custom_BitmaskStruct.reset(); + CompleteMemberDetail detail_my_bitmask = TypeObjectUtils::build_complete_member_detail(name_my_bitmask, member_ann_builtin_my_bitmask, ann_custom_BitmaskStruct); CompleteStructMember member_my_bitmask = TypeObjectUtils::build_complete_struct_member(common_my_bitmask, detail_my_bitmask); - TypeObjectUtils::add_complete_struct_member(member_seq_bitmask_struct, member_my_bitmask); + TypeObjectUtils::add_complete_struct_member(member_seq_BitmaskStruct, member_my_bitmask); } - CompleteStructType struct_type_bitmask_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_bitmask_struct, header_bitmask_struct, member_seq_bitmask_struct); + CompleteStructType struct_type_BitmaskStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_BitmaskStruct, header_BitmaskStruct, member_seq_BitmaskStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_bitmask_struct, type_name_bitmask_struct.to_string(), type_ids_bitmask_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_BitmaskStruct, type_name_BitmaskStruct.to_string(), type_ids_BitmaskStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "bitmask_struct already registered in TypeObjectRegistry for a different type."); + "BitmaskStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.hpp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.hpp index 6ca789acd69..bf618436431 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitmask_struct/bitmask_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/gen/bitmask_structTypeObjectSupport.hpp @@ -50,7 +50,7 @@ eProsima_user_DllExport void register_ColorBitmask_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register bitmask_struct related TypeIdentifier. + * @brief Register BitmaskStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,7 +59,7 @@ eProsima_user_DllExport void register_ColorBitmask_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_bitmask_struct_type_identifier( +eProsima_user_DllExport void register_BitmaskStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/bitset_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl similarity index 89% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/bitset_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl index a8be993ab69..2fea014e0e3 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/bitset_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl @@ -7,7 +7,7 @@ bitset ColorBitset bitfield<12, short> yellow; }; -struct bitset_struct +struct BitsetStruct { ColorBitset my_bitset; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_struct.hpp similarity index 81% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_struct.hpp index dc8880f0db0..b364db5f1d2 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_struct.hpp @@ -90,33 +90,33 @@ struct ColorBitset } }; /*! - * @brief This class represents the structure bitset_struct defined by the user in the IDL file. + * @brief This class represents the structure BitsetStruct defined by the user in the IDL file. * @ingroup bitset_struct */ -class bitset_struct +class BitsetStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport bitset_struct() + eProsima_user_DllExport BitsetStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~bitset_struct() + eProsima_user_DllExport ~BitsetStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object bitset_struct that will be copied. + * @param x Reference to the object BitsetStruct that will be copied. */ - eProsima_user_DllExport bitset_struct( - const bitset_struct& x) + eProsima_user_DllExport BitsetStruct( + const BitsetStruct& x) { m_my_bitset = x.m_my_bitset; @@ -124,20 +124,20 @@ class bitset_struct /*! * @brief Move constructor. - * @param x Reference to the object bitset_struct that will be copied. + * @param x Reference to the object BitsetStruct that will be copied. */ - eProsima_user_DllExport bitset_struct( - bitset_struct&& x) noexcept + eProsima_user_DllExport BitsetStruct( + BitsetStruct&& x) noexcept { m_my_bitset = std::move(x.m_my_bitset); } /*! * @brief Copy assignment. - * @param x Reference to the object bitset_struct that will be copied. + * @param x Reference to the object BitsetStruct that will be copied. */ - eProsima_user_DllExport bitset_struct& operator =( - const bitset_struct& x) + eProsima_user_DllExport BitsetStruct& operator =( + const BitsetStruct& x) { m_my_bitset = x.m_my_bitset; @@ -147,10 +147,10 @@ class bitset_struct /*! * @brief Move assignment. - * @param x Reference to the object bitset_struct that will be copied. + * @param x Reference to the object BitsetStruct that will be copied. */ - eProsima_user_DllExport bitset_struct& operator =( - bitset_struct&& x) noexcept + eProsima_user_DllExport BitsetStruct& operator =( + BitsetStruct&& x) noexcept { m_my_bitset = std::move(x.m_my_bitset); @@ -159,20 +159,20 @@ class bitset_struct /*! * @brief Comparison operator. - * @param x bitset_struct object to compare. + * @param x BitsetStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const bitset_struct& x) const + const BitsetStruct& x) const { return (m_my_bitset == x.m_my_bitset); } /*! * @brief Comparison operator. - * @param x bitset_struct object to compare. + * @param x BitsetStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const bitset_struct& x) const + const BitsetStruct& x) const { return !(*this == x); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.hpp index 41c9571f738..07befbf4d58 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.hpp @@ -24,8 +24,8 @@ #include "bitset_struct.hpp" -constexpr uint32_t bitset_struct_max_cdr_typesize {8UL}; -constexpr uint32_t bitset_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t BitsetStruct_max_cdr_typesize {8UL}; +constexpr uint32_t BitsetStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -36,7 +36,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const bitset_struct& data); + const BitsetStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.ipp similarity index 97% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.ipp index 5c1126e6620..57e875e58b8 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structCdrAux.ipp @@ -95,7 +95,7 @@ eProsima_user_DllExport void deserialize( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const bitset_struct& data, + const BitsetStruct& data, size_t& current_alignment) { static_cast(data); @@ -120,7 +120,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const bitset_struct& data) + const BitsetStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -137,7 +137,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - bitset_struct& data) + BitsetStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -161,7 +161,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const bitset_struct& data) + const BitsetStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.cxx similarity index 82% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.cxx index 6fb212595e7..d327fd7adb3 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -bitset_structPubSubType::bitset_structPubSubType() +BitsetStructPubSubType::BitsetStructPubSubType() { - setName("bitset_struct"); + setName("BitsetStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(bitset_struct::getMaxCdrSerializedSize()); + static_cast(BitsetStruct::getMaxCdrSerializedSize()); #else - bitset_struct_max_cdr_typesize; + BitsetStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = bitset_struct_max_key_cdr_typesize > 16 ? bitset_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = BitsetStruct_max_key_cdr_typesize > 16 ? BitsetStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -bitset_structPubSubType::~bitset_structPubSubType() +BitsetStructPubSubType::~BitsetStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ bitset_structPubSubType::~bitset_structPubSubType() } } -bool bitset_structPubSubType::serialize( +bool BitsetStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const bitset_struct* p_type = static_cast(data); + const BitsetStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool bitset_structPubSubType::serialize( return true; } -bool bitset_structPubSubType::deserialize( +bool BitsetStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - bitset_struct* p_type = static_cast(data); + BitsetStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool bitset_structPubSubType::deserialize( return true; } -std::function bitset_structPubSubType::getSerializedSizeProvider( +std::function BitsetStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function bitset_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function bitset_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function bitset_structPubSubType::getSerializedSizeProvider( }; } -void* bitset_structPubSubType::createData() +void* BitsetStructPubSubType::createData() { - return reinterpret_cast(new bitset_struct()); + return reinterpret_cast(new BitsetStruct()); } -void bitset_structPubSubType::deleteData( +void BitsetStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool bitset_structPubSubType::getKey( +bool BitsetStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool bitset_structPubSubType::getKey( return false; } - const bitset_struct* p_type = static_cast(data); + const BitsetStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - bitset_struct_max_key_cdr_typesize); + BitsetStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool bitset_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || bitset_struct_max_key_cdr_typesize > 16) + if (force_md5 || BitsetStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool bitset_structPubSubType::getKey( return true; } -void bitset_structPubSubType::register_type_object_representation() +void BitsetStructPubSubType::register_type_object_representation() { - register_bitset_struct_type_identifier(type_identifiers_); + register_BitsetStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.hpp index 7246cb4721a..299306c4338 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structPubSubTypes.hpp @@ -39,18 +39,18 @@ /*! - * @brief This class represents the TopicDataType of the type bitset_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type BitsetStruct defined by the user in the IDL file. * @ingroup bitset_struct */ -class bitset_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class BitsetStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef bitset_struct type; + typedef BitsetStruct type; - eProsima_user_DllExport bitset_structPubSubType(); + eProsima_user_DllExport BitsetStructPubSubType(); - eProsima_user_DllExport ~bitset_structPubSubType() override; + eProsima_user_DllExport ~BitsetStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.cxx similarity index 85% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.cxx index 5fd82c272bc..cbe8e365e93 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.cxx @@ -116,25 +116,25 @@ void register_ColorBitset_type_identifier( } } }// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_bitset_struct_type_identifier( - TypeIdentifierPair& type_ids_bitset_struct) +void register_BitsetStruct_type_identifier( + TypeIdentifierPair& type_ids_BitsetStruct) { - ReturnCode_t return_code_bitset_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_bitset_struct = + ReturnCode_t return_code_BitsetStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_BitsetStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "bitset_struct", type_ids_bitset_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_bitset_struct) + "BitsetStruct", type_ids_BitsetStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_BitsetStruct) { - StructTypeFlag struct_flags_bitset_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_BitsetStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_bitset_struct = "bitset_struct"; - eprosima::fastcdr::optional type_ann_builtin_bitset_struct; - eprosima::fastcdr::optional ann_custom_bitset_struct; - CompleteTypeDetail detail_bitset_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_bitset_struct, ann_custom_bitset_struct, type_name_bitset_struct.to_string()); - CompleteStructHeader header_bitset_struct; - header_bitset_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_bitset_struct); - CompleteStructMemberSeq member_seq_bitset_struct; + QualifiedTypeName type_name_BitsetStruct = "BitsetStruct"; + eprosima::fastcdr::optional type_ann_builtin_BitsetStruct; + eprosima::fastcdr::optional ann_custom_BitsetStruct; + CompleteTypeDetail detail_BitsetStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BitsetStruct, ann_custom_BitsetStruct, type_name_BitsetStruct.to_string()); + CompleteStructHeader header_BitsetStruct; + header_BitsetStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BitsetStruct); + CompleteStructMemberSeq member_seq_BitsetStruct; { TypeIdentifierPair type_ids_my_bitset; ReturnCode_t return_code_my_bitset {eprosima::fastdds::dds::RETCODE_OK}; @@ -158,17 +158,17 @@ void register_bitset_struct_type_identifier( } MemberName name_my_bitset = "my_bitset"; eprosima::fastcdr::optional member_ann_builtin_my_bitset; - ann_custom_bitset_struct.reset(); - CompleteMemberDetail detail_my_bitset = TypeObjectUtils::build_complete_member_detail(name_my_bitset, member_ann_builtin_my_bitset, ann_custom_bitset_struct); + ann_custom_BitsetStruct.reset(); + CompleteMemberDetail detail_my_bitset = TypeObjectUtils::build_complete_member_detail(name_my_bitset, member_ann_builtin_my_bitset, ann_custom_BitsetStruct); CompleteStructMember member_my_bitset = TypeObjectUtils::build_complete_struct_member(common_my_bitset, detail_my_bitset); - TypeObjectUtils::add_complete_struct_member(member_seq_bitset_struct, member_my_bitset); + TypeObjectUtils::add_complete_struct_member(member_seq_BitsetStruct, member_my_bitset); } - CompleteStructType struct_type_bitset_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_bitset_struct, header_bitset_struct, member_seq_bitset_struct); + CompleteStructType struct_type_BitsetStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_BitsetStruct, header_BitsetStruct, member_seq_BitsetStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_bitset_struct, type_name_bitset_struct.to_string(), type_ids_bitset_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_BitsetStruct, type_name_BitsetStruct.to_string(), type_ids_BitsetStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "bitset_struct already registered in TypeObjectRegistry for a different type."); + "BitsetStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.hpp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.hpp index dae00edc87d..e464ae9f29f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/bitset_struct/bitset_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/gen/bitset_structTypeObjectSupport.hpp @@ -50,7 +50,7 @@ eProsima_user_DllExport void register_ColorBitset_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register bitset_struct related TypeIdentifier. + * @brief Register BitsetStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,7 +59,7 @@ eProsima_user_DllExport void register_ColorBitset_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_bitset_struct_type_identifier( +eProsima_user_DllExport void register_BitsetStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/enum_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl similarity index 64% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/enum_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl index c40eae6ea45..951dd5e147f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/enum_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl @@ -5,8 +5,7 @@ enum ColorEnum BLUE }; -struct enum_struct +struct EnumStruct { - unsigned long index; ColorEnum enum_value; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_struct.hpp similarity index 64% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_struct.hpp index 3e39c0433c7..b832414f09a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_struct.hpp @@ -60,61 +60,56 @@ enum class ColorEnum : int32_t BLUE }; /*! - * @brief This class represents the structure enum_struct defined by the user in the IDL file. + * @brief This class represents the structure EnumStruct defined by the user in the IDL file. * @ingroup enum_struct */ -class enum_struct +class EnumStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport enum_struct() + eProsima_user_DllExport EnumStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~enum_struct() + eProsima_user_DllExport ~EnumStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object enum_struct that will be copied. + * @param x Reference to the object EnumStruct that will be copied. */ - eProsima_user_DllExport enum_struct( - const enum_struct& x) + eProsima_user_DllExport EnumStruct( + const EnumStruct& x) { - m_index = x.m_index; - m_enum_value = x.m_enum_value; } /*! * @brief Move constructor. - * @param x Reference to the object enum_struct that will be copied. + * @param x Reference to the object EnumStruct that will be copied. */ - eProsima_user_DllExport enum_struct( - enum_struct&& x) noexcept + eProsima_user_DllExport EnumStruct( + EnumStruct&& x) noexcept { - m_index = x.m_index; m_enum_value = x.m_enum_value; } /*! * @brief Copy assignment. - * @param x Reference to the object enum_struct that will be copied. + * @param x Reference to the object EnumStruct that will be copied. */ - eProsima_user_DllExport enum_struct& operator =( - const enum_struct& x) + eProsima_user_DllExport EnumStruct& operator =( + const EnumStruct& x) { - m_index = x.m_index; - m_enum_value = x.m_enum_value; return *this; @@ -122,67 +117,36 @@ class enum_struct /*! * @brief Move assignment. - * @param x Reference to the object enum_struct that will be copied. + * @param x Reference to the object EnumStruct that will be copied. */ - eProsima_user_DllExport enum_struct& operator =( - enum_struct&& x) noexcept + eProsima_user_DllExport EnumStruct& operator =( + EnumStruct&& x) noexcept { - m_index = x.m_index; m_enum_value = x.m_enum_value; return *this; } /*! * @brief Comparison operator. - * @param x enum_struct object to compare. + * @param x EnumStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const enum_struct& x) const + const EnumStruct& x) const { - return (m_index == x.m_index && - m_enum_value == x.m_enum_value); + return (m_enum_value == x.m_enum_value); } /*! * @brief Comparison operator. - * @param x enum_struct object to compare. + * @param x EnumStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const enum_struct& x) const + const EnumStruct& x) const { return !(*this == x); } - /*! - * @brief This function sets a value in member index - * @param _index New value for member index - */ - eProsima_user_DllExport void index( - uint32_t _index) - { - m_index = _index; - } - - /*! - * @brief This function returns the value of member index - * @return Value of member index - */ - eProsima_user_DllExport uint32_t index() const - { - return m_index; - } - - /*! - * @brief This function returns a reference to member index - * @return Reference to member index - */ - eProsima_user_DllExport uint32_t& index() - { - return m_index; - } - - /*! * @brief This function sets a value in member enum_value * @param _enum_value New value for member enum_value @@ -215,7 +179,6 @@ class enum_struct private: - uint32_t m_index{0}; ColorEnum m_enum_value{ColorEnum::RED}; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.hpp index 285c5fc7be5..7bb13168503 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.hpp @@ -24,8 +24,8 @@ #include "enum_struct.hpp" -constexpr uint32_t enum_struct_max_cdr_typesize {12UL}; -constexpr uint32_t enum_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t EnumStruct_max_cdr_typesize {8UL}; +constexpr uint32_t EnumStruct_max_key_cdr_typesize {0UL}; @@ -37,7 +37,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const enum_struct& data); + const EnumStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.ipp similarity index 86% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.ipp index 8a43f231676..33876ba2bba 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structCdrAux.ipp @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const enum_struct& data, + const EnumStruct& data, size_t& current_alignment) { static_cast(data); @@ -51,9 +51,6 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.index(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.enum_value(), current_alignment); @@ -65,7 +62,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const enum_struct& data) + const EnumStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -74,8 +71,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.index() - << eprosima::fastcdr::MemberId(1) << data.enum_value() + << eprosima::fastcdr::MemberId(0) << data.enum_value() ; scdr.end_serialize_type(current_state); } @@ -83,7 +79,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - enum_struct& data) + EnumStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -94,10 +90,6 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.index(); - break; - - case 1: dcdr >> data.enum_value(); break; @@ -111,7 +103,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const enum_struct& data) + const EnumStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.cxx similarity index 83% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.cxx index a742fab72a9..e6d63cec8b4 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -enum_structPubSubType::enum_structPubSubType() +EnumStructPubSubType::EnumStructPubSubType() { - setName("enum_struct"); + setName("EnumStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(enum_struct::getMaxCdrSerializedSize()); + static_cast(EnumStruct::getMaxCdrSerializedSize()); #else - enum_struct_max_cdr_typesize; + EnumStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = enum_struct_max_key_cdr_typesize > 16 ? enum_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = EnumStruct_max_key_cdr_typesize > 16 ? EnumStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -enum_structPubSubType::~enum_structPubSubType() +EnumStructPubSubType::~EnumStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ enum_structPubSubType::~enum_structPubSubType() } } -bool enum_structPubSubType::serialize( +bool EnumStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const enum_struct* p_type = static_cast(data); + const EnumStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool enum_structPubSubType::serialize( return true; } -bool enum_structPubSubType::deserialize( +bool EnumStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - enum_struct* p_type = static_cast(data); + EnumStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool enum_structPubSubType::deserialize( return true; } -std::function enum_structPubSubType::getSerializedSizeProvider( +std::function EnumStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function enum_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function enum_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function enum_structPubSubType::getSerializedSizeProvider( }; } -void* enum_structPubSubType::createData() +void* EnumStructPubSubType::createData() { - return reinterpret_cast(new enum_struct()); + return reinterpret_cast(new EnumStruct()); } -void enum_structPubSubType::deleteData( +void EnumStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool enum_structPubSubType::getKey( +bool EnumStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool enum_structPubSubType::getKey( return false; } - const enum_struct* p_type = static_cast(data); + const EnumStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - enum_struct_max_key_cdr_typesize); + EnumStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool enum_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || enum_struct_max_key_cdr_typesize > 16) + if (force_md5 || EnumStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool enum_structPubSubType::getKey( return true; } -void enum_structPubSubType::register_type_object_representation() +void EnumStructPubSubType::register_type_object_representation() { - register_enum_struct_type_identifier(type_identifiers_); + register_EnumStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.hpp index b69dda7e02d..4a0e3122b01 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structPubSubTypes.hpp @@ -39,18 +39,18 @@ /*! - * @brief This class represents the TopicDataType of the type enum_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type EnumStruct defined by the user in the IDL file. * @ingroup enum_struct */ -class enum_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class EnumStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef enum_struct type; + typedef EnumStruct type; - eProsima_user_DllExport enum_structPubSubType(); + eProsima_user_DllExport EnumStructPubSubType(); - eProsima_user_DllExport ~enum_structPubSubType() override; + eProsima_user_DllExport ~EnumStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.cxx similarity index 69% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.cxx index 642e3524470..38a0fbf0761 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.cxx @@ -96,55 +96,25 @@ void register_ColorEnum_type_identifier( } } }// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_enum_struct_type_identifier( - TypeIdentifierPair& type_ids_enum_struct) +void register_EnumStruct_type_identifier( + TypeIdentifierPair& type_ids_EnumStruct) { - ReturnCode_t return_code_enum_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_enum_struct = + ReturnCode_t return_code_EnumStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_EnumStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "enum_struct", type_ids_enum_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_enum_struct) + "EnumStruct", type_ids_EnumStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_EnumStruct) { - StructTypeFlag struct_flags_enum_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_EnumStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_enum_struct = "enum_struct"; - eprosima::fastcdr::optional type_ann_builtin_enum_struct; - eprosima::fastcdr::optional ann_custom_enum_struct; - CompleteTypeDetail detail_enum_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_enum_struct, ann_custom_enum_struct, type_name_enum_struct.to_string()); - CompleteStructHeader header_enum_struct; - header_enum_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_enum_struct); - CompleteStructMemberSeq member_seq_enum_struct; - { - TypeIdentifierPair type_ids_index; - ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; - return_code_index = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint32_t", type_ids_index); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_index = 0x00000000; - bool common_index_ec {false}; - CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; - if (!common_index_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); - return; - } - MemberName name_index = "index"; - eprosima::fastcdr::optional member_ann_builtin_index; - ann_custom_enum_struct.reset(); - CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_enum_struct); - CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); - TypeObjectUtils::add_complete_struct_member(member_seq_enum_struct, member_index); - } + QualifiedTypeName type_name_EnumStruct = "EnumStruct"; + eprosima::fastcdr::optional type_ann_builtin_EnumStruct; + eprosima::fastcdr::optional ann_custom_EnumStruct; + CompleteTypeDetail detail_EnumStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_EnumStruct, ann_custom_EnumStruct, type_name_EnumStruct.to_string()); + CompleteStructHeader header_EnumStruct; + header_EnumStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_EnumStruct); + CompleteStructMemberSeq member_seq_EnumStruct; { TypeIdentifierPair type_ids_enum_value; ReturnCode_t return_code_enum_value {eprosima::fastdds::dds::RETCODE_OK}; @@ -158,7 +128,7 @@ void register_enum_struct_type_identifier( } StructMemberFlag member_flags_enum_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_enum_value = 0x00000001; + MemberId member_id_enum_value = 0x00000000; bool common_enum_value_ec {false}; CommonStructMember common_enum_value {TypeObjectUtils::build_common_struct_member(member_id_enum_value, member_flags_enum_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_enum_value, common_enum_value_ec))}; if (!common_enum_value_ec) @@ -168,17 +138,17 @@ void register_enum_struct_type_identifier( } MemberName name_enum_value = "enum_value"; eprosima::fastcdr::optional member_ann_builtin_enum_value; - ann_custom_enum_struct.reset(); - CompleteMemberDetail detail_enum_value = TypeObjectUtils::build_complete_member_detail(name_enum_value, member_ann_builtin_enum_value, ann_custom_enum_struct); + ann_custom_EnumStruct.reset(); + CompleteMemberDetail detail_enum_value = TypeObjectUtils::build_complete_member_detail(name_enum_value, member_ann_builtin_enum_value, ann_custom_EnumStruct); CompleteStructMember member_enum_value = TypeObjectUtils::build_complete_struct_member(common_enum_value, detail_enum_value); - TypeObjectUtils::add_complete_struct_member(member_seq_enum_struct, member_enum_value); + TypeObjectUtils::add_complete_struct_member(member_seq_EnumStruct, member_enum_value); } - CompleteStructType struct_type_enum_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_enum_struct, header_enum_struct, member_seq_enum_struct); + CompleteStructType struct_type_EnumStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_EnumStruct, header_EnumStruct, member_seq_EnumStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_enum_struct, type_name_enum_struct.to_string(), type_ids_enum_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_EnumStruct, type_name_EnumStruct.to_string(), type_ids_EnumStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "enum_struct already registered in TypeObjectRegistry for a different type."); + "EnumStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.hpp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.hpp index 70026eb9ddf..ac765dcafd5 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/enum_struct/enum_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/enum_struct/gen/enum_structTypeObjectSupport.hpp @@ -50,7 +50,7 @@ eProsima_user_DllExport void register_ColorEnum_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register enum_struct related TypeIdentifier. + * @brief Register EnumStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,7 +59,7 @@ eProsima_user_DllExport void register_ColorEnum_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_enum_struct_type_identifier( +eProsima_user_DllExport void register_EnumStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl new file mode 100644 index 00000000000..ae252ac00a9 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl @@ -0,0 +1,23 @@ +@extensibility(FINAL) +struct FinalStruct +{ + octet my_value; +}; + +@extensibility(MUTABLE) +struct MutableStruct +{ + octet my_value; +}; + +struct AppendableStruct +{ + octet my_value; +}; + +struct ExtensibilityStruct +{ + FinalStruct my_final_struct; + MutableStruct my_mutable_struct; + AppendableStruct my_appendable_struct; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_struct.hpp similarity index 51% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_struct.hpp index 8d591917d4f..9922d45e9b3 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_struct.hpp @@ -78,7 +78,7 @@ class FinalStruct eProsima_user_DllExport FinalStruct( const FinalStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; } @@ -89,7 +89,7 @@ class FinalStruct eProsima_user_DllExport FinalStruct( FinalStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; } /*! @@ -100,7 +100,7 @@ class FinalStruct const FinalStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -113,7 +113,7 @@ class FinalStruct FinalStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -124,7 +124,7 @@ class FinalStruct eProsima_user_DllExport bool operator ==( const FinalStruct& x) const { - return (m_color == x.m_color); + return (m_my_value == x.m_my_value); } /*! @@ -138,38 +138,38 @@ class FinalStruct } /*! - * @brief This function sets a value in member color - * @param _color New value for member color + * @brief This function sets a value in member my_value + * @param _my_value New value for member my_value */ - eProsima_user_DllExport void color( - uint8_t _color) + eProsima_user_DllExport void my_value( + uint8_t _my_value) { - m_color = _color; + m_my_value = _my_value; } /*! - * @brief This function returns the value of member color - * @return Value of member color + * @brief This function returns the value of member my_value + * @return Value of member my_value */ - eProsima_user_DllExport uint8_t color() const + eProsima_user_DllExport uint8_t my_value() const { - return m_color; + return m_my_value; } /*! - * @brief This function returns a reference to member color - * @return Reference to member color + * @brief This function returns a reference to member my_value + * @return Reference to member my_value */ - eProsima_user_DllExport uint8_t& color() + eProsima_user_DllExport uint8_t& my_value() { - return m_color; + return m_my_value; } private: - uint8_t m_color{0}; + uint8_t m_my_value{0}; }; /*! @@ -201,7 +201,7 @@ class MutableStruct eProsima_user_DllExport MutableStruct( const MutableStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; } @@ -212,7 +212,7 @@ class MutableStruct eProsima_user_DllExport MutableStruct( MutableStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; } /*! @@ -223,7 +223,7 @@ class MutableStruct const MutableStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -236,7 +236,7 @@ class MutableStruct MutableStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -247,7 +247,7 @@ class MutableStruct eProsima_user_DllExport bool operator ==( const MutableStruct& x) const { - return (m_color == x.m_color); + return (m_my_value == x.m_my_value); } /*! @@ -261,38 +261,38 @@ class MutableStruct } /*! - * @brief This function sets a value in member color - * @param _color New value for member color + * @brief This function sets a value in member my_value + * @param _my_value New value for member my_value */ - eProsima_user_DllExport void color( - uint8_t _color) + eProsima_user_DllExport void my_value( + uint8_t _my_value) { - m_color = _color; + m_my_value = _my_value; } /*! - * @brief This function returns the value of member color - * @return Value of member color + * @brief This function returns the value of member my_value + * @return Value of member my_value */ - eProsima_user_DllExport uint8_t color() const + eProsima_user_DllExport uint8_t my_value() const { - return m_color; + return m_my_value; } /*! - * @brief This function returns a reference to member color - * @return Reference to member color + * @brief This function returns a reference to member my_value + * @return Reference to member my_value */ - eProsima_user_DllExport uint8_t& color() + eProsima_user_DllExport uint8_t& my_value() { - return m_color; + return m_my_value; } private: - uint8_t m_color{0}; + uint8_t m_my_value{0}; }; /*! @@ -324,7 +324,7 @@ class AppendableStruct eProsima_user_DllExport AppendableStruct( const AppendableStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; } @@ -335,7 +335,7 @@ class AppendableStruct eProsima_user_DllExport AppendableStruct( AppendableStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; } /*! @@ -346,7 +346,7 @@ class AppendableStruct const AppendableStruct& x) { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -359,7 +359,7 @@ class AppendableStruct AppendableStruct&& x) noexcept { - m_color = x.m_color; + m_my_value = x.m_my_value; return *this; } @@ -370,7 +370,7 @@ class AppendableStruct eProsima_user_DllExport bool operator ==( const AppendableStruct& x) const { - return (m_color == x.m_color); + return (m_my_value == x.m_my_value); } /*! @@ -384,265 +384,265 @@ class AppendableStruct } /*! - * @brief This function sets a value in member color - * @param _color New value for member color + * @brief This function sets a value in member my_value + * @param _my_value New value for member my_value */ - eProsima_user_DllExport void color( - uint8_t _color) + eProsima_user_DllExport void my_value( + uint8_t _my_value) { - m_color = _color; + m_my_value = _my_value; } /*! - * @brief This function returns the value of member color - * @return Value of member color + * @brief This function returns the value of member my_value + * @return Value of member my_value */ - eProsima_user_DllExport uint8_t color() const + eProsima_user_DllExport uint8_t my_value() const { - return m_color; + return m_my_value; } /*! - * @brief This function returns a reference to member color - * @return Reference to member color + * @brief This function returns a reference to member my_value + * @return Reference to member my_value */ - eProsima_user_DllExport uint8_t& color() + eProsima_user_DllExport uint8_t& my_value() { - return m_color; + return m_my_value; } private: - uint8_t m_color{0}; + uint8_t m_my_value{0}; }; /*! - * @brief This class represents the structure extensibility_struct defined by the user in the IDL file. + * @brief This class represents the structure ExtensibilityStruct defined by the user in the IDL file. * @ingroup extensibility_struct */ -class extensibility_struct +class ExtensibilityStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport extensibility_struct() + eProsima_user_DllExport ExtensibilityStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~extensibility_struct() + eProsima_user_DllExport ~ExtensibilityStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object extensibility_struct that will be copied. + * @param x Reference to the object ExtensibilityStruct that will be copied. */ - eProsima_user_DllExport extensibility_struct( - const extensibility_struct& x) + eProsima_user_DllExport ExtensibilityStruct( + const ExtensibilityStruct& x) { - m_red = x.m_red; + m_my_final_struct = x.m_my_final_struct; - m_blue = x.m_blue; + m_my_mutable_struct = x.m_my_mutable_struct; - m_green = x.m_green; + m_my_appendable_struct = x.m_my_appendable_struct; } /*! * @brief Move constructor. - * @param x Reference to the object extensibility_struct that will be copied. + * @param x Reference to the object ExtensibilityStruct that will be copied. */ - eProsima_user_DllExport extensibility_struct( - extensibility_struct&& x) noexcept + eProsima_user_DllExport ExtensibilityStruct( + ExtensibilityStruct&& x) noexcept { - m_red = std::move(x.m_red); - m_blue = std::move(x.m_blue); - m_green = std::move(x.m_green); + m_my_final_struct = std::move(x.m_my_final_struct); + m_my_mutable_struct = std::move(x.m_my_mutable_struct); + m_my_appendable_struct = std::move(x.m_my_appendable_struct); } /*! * @brief Copy assignment. - * @param x Reference to the object extensibility_struct that will be copied. + * @param x Reference to the object ExtensibilityStruct that will be copied. */ - eProsima_user_DllExport extensibility_struct& operator =( - const extensibility_struct& x) + eProsima_user_DllExport ExtensibilityStruct& operator =( + const ExtensibilityStruct& x) { - m_red = x.m_red; + m_my_final_struct = x.m_my_final_struct; - m_blue = x.m_blue; + m_my_mutable_struct = x.m_my_mutable_struct; - m_green = x.m_green; + m_my_appendable_struct = x.m_my_appendable_struct; return *this; } /*! * @brief Move assignment. - * @param x Reference to the object extensibility_struct that will be copied. + * @param x Reference to the object ExtensibilityStruct that will be copied. */ - eProsima_user_DllExport extensibility_struct& operator =( - extensibility_struct&& x) noexcept + eProsima_user_DllExport ExtensibilityStruct& operator =( + ExtensibilityStruct&& x) noexcept { - m_red = std::move(x.m_red); - m_blue = std::move(x.m_blue); - m_green = std::move(x.m_green); + m_my_final_struct = std::move(x.m_my_final_struct); + m_my_mutable_struct = std::move(x.m_my_mutable_struct); + m_my_appendable_struct = std::move(x.m_my_appendable_struct); return *this; } /*! * @brief Comparison operator. - * @param x extensibility_struct object to compare. + * @param x ExtensibilityStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const extensibility_struct& x) const + const ExtensibilityStruct& x) const { - return (m_red == x.m_red && - m_blue == x.m_blue && - m_green == x.m_green); + return (m_my_final_struct == x.m_my_final_struct && + m_my_mutable_struct == x.m_my_mutable_struct && + m_my_appendable_struct == x.m_my_appendable_struct); } /*! * @brief Comparison operator. - * @param x extensibility_struct object to compare. + * @param x ExtensibilityStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const extensibility_struct& x) const + const ExtensibilityStruct& x) const { return !(*this == x); } /*! - * @brief This function copies the value in member red - * @param _red New value to be copied in member red + * @brief This function copies the value in member my_final_struct + * @param _my_final_struct New value to be copied in member my_final_struct */ - eProsima_user_DllExport void red( - const FinalStruct& _red) + eProsima_user_DllExport void my_final_struct( + const FinalStruct& _my_final_struct) { - m_red = _red; + m_my_final_struct = _my_final_struct; } /*! - * @brief This function moves the value in member red - * @param _red New value to be moved in member red + * @brief This function moves the value in member my_final_struct + * @param _my_final_struct New value to be moved in member my_final_struct */ - eProsima_user_DllExport void red( - FinalStruct&& _red) + eProsima_user_DllExport void my_final_struct( + FinalStruct&& _my_final_struct) { - m_red = std::move(_red); + m_my_final_struct = std::move(_my_final_struct); } /*! - * @brief This function returns a constant reference to member red - * @return Constant reference to member red + * @brief This function returns a constant reference to member my_final_struct + * @return Constant reference to member my_final_struct */ - eProsima_user_DllExport const FinalStruct& red() const + eProsima_user_DllExport const FinalStruct& my_final_struct() const { - return m_red; + return m_my_final_struct; } /*! - * @brief This function returns a reference to member red - * @return Reference to member red + * @brief This function returns a reference to member my_final_struct + * @return Reference to member my_final_struct */ - eProsima_user_DllExport FinalStruct& red() + eProsima_user_DllExport FinalStruct& my_final_struct() { - return m_red; + return m_my_final_struct; } /*! - * @brief This function copies the value in member blue - * @param _blue New value to be copied in member blue + * @brief This function copies the value in member my_mutable_struct + * @param _my_mutable_struct New value to be copied in member my_mutable_struct */ - eProsima_user_DllExport void blue( - const MutableStruct& _blue) + eProsima_user_DllExport void my_mutable_struct( + const MutableStruct& _my_mutable_struct) { - m_blue = _blue; + m_my_mutable_struct = _my_mutable_struct; } /*! - * @brief This function moves the value in member blue - * @param _blue New value to be moved in member blue + * @brief This function moves the value in member my_mutable_struct + * @param _my_mutable_struct New value to be moved in member my_mutable_struct */ - eProsima_user_DllExport void blue( - MutableStruct&& _blue) + eProsima_user_DllExport void my_mutable_struct( + MutableStruct&& _my_mutable_struct) { - m_blue = std::move(_blue); + m_my_mutable_struct = std::move(_my_mutable_struct); } /*! - * @brief This function returns a constant reference to member blue - * @return Constant reference to member blue + * @brief This function returns a constant reference to member my_mutable_struct + * @return Constant reference to member my_mutable_struct */ - eProsima_user_DllExport const MutableStruct& blue() const + eProsima_user_DllExport const MutableStruct& my_mutable_struct() const { - return m_blue; + return m_my_mutable_struct; } /*! - * @brief This function returns a reference to member blue - * @return Reference to member blue + * @brief This function returns a reference to member my_mutable_struct + * @return Reference to member my_mutable_struct */ - eProsima_user_DllExport MutableStruct& blue() + eProsima_user_DllExport MutableStruct& my_mutable_struct() { - return m_blue; + return m_my_mutable_struct; } /*! - * @brief This function copies the value in member green - * @param _green New value to be copied in member green + * @brief This function copies the value in member my_appendable_struct + * @param _my_appendable_struct New value to be copied in member my_appendable_struct */ - eProsima_user_DllExport void green( - const AppendableStruct& _green) + eProsima_user_DllExport void my_appendable_struct( + const AppendableStruct& _my_appendable_struct) { - m_green = _green; + m_my_appendable_struct = _my_appendable_struct; } /*! - * @brief This function moves the value in member green - * @param _green New value to be moved in member green + * @brief This function moves the value in member my_appendable_struct + * @param _my_appendable_struct New value to be moved in member my_appendable_struct */ - eProsima_user_DllExport void green( - AppendableStruct&& _green) + eProsima_user_DllExport void my_appendable_struct( + AppendableStruct&& _my_appendable_struct) { - m_green = std::move(_green); + m_my_appendable_struct = std::move(_my_appendable_struct); } /*! - * @brief This function returns a constant reference to member green - * @return Constant reference to member green + * @brief This function returns a constant reference to member my_appendable_struct + * @return Constant reference to member my_appendable_struct */ - eProsima_user_DllExport const AppendableStruct& green() const + eProsima_user_DllExport const AppendableStruct& my_appendable_struct() const { - return m_green; + return m_my_appendable_struct; } /*! - * @brief This function returns a reference to member green - * @return Reference to member green + * @brief This function returns a reference to member my_appendable_struct + * @return Reference to member my_appendable_struct */ - eProsima_user_DllExport AppendableStruct& green() + eProsima_user_DllExport AppendableStruct& my_appendable_struct() { - return m_green; + return m_my_appendable_struct; } private: - FinalStruct m_red; - MutableStruct m_blue; - AppendableStruct m_green; + FinalStruct m_my_final_struct; + MutableStruct m_my_mutable_struct; + AppendableStruct m_my_appendable_struct; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.hpp similarity index 91% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.hpp index 825c56074be..43a956fa458 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.hpp @@ -27,15 +27,15 @@ constexpr uint32_t MutableStruct_max_cdr_typesize {12UL}; constexpr uint32_t MutableStruct_max_key_cdr_typesize {0UL}; +constexpr uint32_t ExtensibilityStruct_max_cdr_typesize {25UL}; +constexpr uint32_t ExtensibilityStruct_max_key_cdr_typesize {0UL}; + constexpr uint32_t FinalStruct_max_cdr_typesize {1UL}; constexpr uint32_t FinalStruct_max_key_cdr_typesize {0UL}; constexpr uint32_t AppendableStruct_max_cdr_typesize {5UL}; constexpr uint32_t AppendableStruct_max_key_cdr_typesize {0UL}; -constexpr uint32_t extensibility_struct_max_cdr_typesize {25UL}; -constexpr uint32_t extensibility_struct_max_key_cdr_typesize {0UL}; - namespace eprosima { namespace fastcdr { @@ -57,7 +57,7 @@ eProsima_user_DllExport void serialize_key( eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const extensibility_struct& data); + const ExtensibilityStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.ipp similarity index 89% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.ipp index 4f2f6158aa5..58f6583fc39 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structCdrAux.ipp @@ -51,7 +51,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.color(), current_alignment); + data.my_value(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -71,7 +71,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.color() + << eprosima::fastcdr::MemberId(0) << data.my_value() ; scdr.end_serialize_type(current_state); } @@ -90,7 +90,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.color(); + dcdr >> data.my_value(); break; default: @@ -127,7 +127,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0x00000000), - data.color(), current_alignment); + data.my_value(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -147,7 +147,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PL_CDR); scdr - << eprosima::fastcdr::MemberId(0x00000000) << data.color() + << eprosima::fastcdr::MemberId(0x00000000) << data.my_value() ; scdr.end_serialize_type(current_state); } @@ -166,7 +166,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0x00000000: - dcdr >> data.color(); + dcdr >> data.my_value(); break; default: @@ -203,7 +203,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.color(), current_alignment); + data.my_value(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -223,7 +223,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.color() + << eprosima::fastcdr::MemberId(0) << data.my_value() ; scdr.end_serialize_type(current_state); } @@ -242,7 +242,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.color(); + dcdr >> data.my_value(); break; default: @@ -265,7 +265,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const extensibility_struct& data, + const ExtensibilityStruct& data, size_t& current_alignment) { static_cast(data); @@ -279,13 +279,13 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.red(), current_alignment); + data.my_final_struct(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.blue(), current_alignment); + data.my_mutable_struct(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.green(), current_alignment); + data.my_appendable_struct(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -296,7 +296,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const extensibility_struct& data) + const ExtensibilityStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -305,9 +305,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.red() - << eprosima::fastcdr::MemberId(1) << data.blue() - << eprosima::fastcdr::MemberId(2) << data.green() + << eprosima::fastcdr::MemberId(0) << data.my_final_struct() + << eprosima::fastcdr::MemberId(1) << data.my_mutable_struct() + << eprosima::fastcdr::MemberId(2) << data.my_appendable_struct() ; scdr.end_serialize_type(current_state); } @@ -315,7 +315,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - extensibility_struct& data) + ExtensibilityStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -326,15 +326,15 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.red(); + dcdr >> data.my_final_struct(); break; case 1: - dcdr >> data.blue(); + dcdr >> data.my_mutable_struct(); break; case 2: - dcdr >> data.green(); + dcdr >> data.my_appendable_struct(); break; default: @@ -347,7 +347,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const extensibility_struct& data) + const ExtensibilityStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.cxx similarity index 94% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.cxx index b783cbdbcca..87070348864 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.cxx @@ -610,24 +610,24 @@ void AppendableStructPubSubType::register_type_object_representation() register_AppendableStruct_type_identifier(type_identifiers_); } -extensibility_structPubSubType::extensibility_structPubSubType() +ExtensibilityStructPubSubType::ExtensibilityStructPubSubType() { - setName("extensibility_struct"); + setName("ExtensibilityStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(extensibility_struct::getMaxCdrSerializedSize()); + static_cast(ExtensibilityStruct::getMaxCdrSerializedSize()); #else - extensibility_struct_max_cdr_typesize; + ExtensibilityStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = extensibility_struct_max_key_cdr_typesize > 16 ? extensibility_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = ExtensibilityStruct_max_key_cdr_typesize > 16 ? ExtensibilityStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -extensibility_structPubSubType::~extensibility_structPubSubType() +ExtensibilityStructPubSubType::~ExtensibilityStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -635,12 +635,12 @@ extensibility_structPubSubType::~extensibility_structPubSubType() } } -bool extensibility_structPubSubType::serialize( +bool ExtensibilityStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const extensibility_struct* p_type = static_cast(data); + const ExtensibilityStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -677,14 +677,14 @@ bool extensibility_structPubSubType::serialize( return true; } -bool extensibility_structPubSubType::deserialize( +bool ExtensibilityStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - extensibility_struct* p_type = static_cast(data); + ExtensibilityStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -711,7 +711,7 @@ bool extensibility_structPubSubType::deserialize( return true; } -std::function extensibility_structPubSubType::getSerializedSizeProvider( +std::function ExtensibilityStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -719,7 +719,7 @@ std::function extensibility_structPubSubType::getSerializedSizeProvi { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -729,7 +729,7 @@ std::function extensibility_structPubSubType::getSerializedSizeProvi eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -740,18 +740,18 @@ std::function extensibility_structPubSubType::getSerializedSizeProvi }; } -void* extensibility_structPubSubType::createData() +void* ExtensibilityStructPubSubType::createData() { - return reinterpret_cast(new extensibility_struct()); + return reinterpret_cast(new ExtensibilityStruct()); } -void extensibility_structPubSubType::deleteData( +void ExtensibilityStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool extensibility_structPubSubType::getKey( +bool ExtensibilityStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -761,11 +761,11 @@ bool extensibility_structPubSubType::getKey( return false; } - const extensibility_struct* p_type = static_cast(data); + const ExtensibilityStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - extensibility_struct_max_key_cdr_typesize); + ExtensibilityStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -774,7 +774,7 @@ bool extensibility_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || extensibility_struct_max_key_cdr_typesize > 16) + if (force_md5 || ExtensibilityStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -798,9 +798,9 @@ bool extensibility_structPubSubType::getKey( return true; } -void extensibility_structPubSubType::register_type_object_representation() +void ExtensibilityStructPubSubType::register_type_object_representation() { - register_extensibility_struct_type_identifier(type_identifiers_); + register_ExtensibilityStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.hpp similarity index 96% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.hpp index 4c2ddfd9e3c..28ad65cb910 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structPubSubTypes.hpp @@ -59,7 +59,7 @@ struct FinalStruct_f FinalStruct_f); }; -template struct FinalStruct_rob; +template struct FinalStruct_rob; template inline size_t constexpr FinalStruct_offset_of() @@ -367,18 +367,18 @@ class AppendableStructPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type extensibility_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type ExtensibilityStruct defined by the user in the IDL file. * @ingroup extensibility_struct */ -class extensibility_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class ExtensibilityStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef extensibility_struct type; + typedef ExtensibilityStruct type; - eProsima_user_DllExport extensibility_structPubSubType(); + eProsima_user_DllExport ExtensibilityStructPubSubType(); - eProsima_user_DllExport ~extensibility_structPubSubType() override; + eProsima_user_DllExport ~ExtensibilityStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.cxx similarity index 54% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.cxx index 860f5c8368c..f3eca37a9d0 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.cxx @@ -66,34 +66,34 @@ void register_FinalStruct_type_identifier( header_FinalStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FinalStruct); CompleteStructMemberSeq member_seq_FinalStruct; { - TypeIdentifierPair type_ids_color; - ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; - return_code_color = + TypeIdentifierPair type_ids_my_value; + ReturnCode_t return_code_my_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_value = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_byte", type_ids_color); + "_byte", type_ids_my_value); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_value) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + "my_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); return; } - StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_color = 0x00000000; - bool common_color_ec {false}; - CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; - if (!common_color_ec) + MemberId member_id_my_value = 0x00000000; + bool common_my_value_ec {false}; + CommonStructMember common_my_value {TypeObjectUtils::build_common_struct_member(member_id_my_value, member_flags_my_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_value, common_my_value_ec))}; + if (!common_my_value_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_value member TypeIdentifier inconsistent."); return; } - MemberName name_color = "color"; - eprosima::fastcdr::optional member_ann_builtin_color; + MemberName name_my_value = "my_value"; + eprosima::fastcdr::optional member_ann_builtin_my_value; ann_custom_FinalStruct.reset(); - CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_FinalStruct); - CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); - TypeObjectUtils::add_complete_struct_member(member_seq_FinalStruct, member_color); + CompleteMemberDetail detail_my_value = TypeObjectUtils::build_complete_member_detail(name_my_value, member_ann_builtin_my_value, ann_custom_FinalStruct); + CompleteStructMember member_my_value = TypeObjectUtils::build_complete_struct_member(common_my_value, detail_my_value); + TypeObjectUtils::add_complete_struct_member(member_seq_FinalStruct, member_my_value); } CompleteStructType struct_type_FinalStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FinalStruct, header_FinalStruct, member_seq_FinalStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == @@ -132,34 +132,34 @@ void register_MutableStruct_type_identifier( header_MutableStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_MutableStruct); CompleteStructMemberSeq member_seq_MutableStruct; { - TypeIdentifierPair type_ids_color; - ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; - return_code_color = + TypeIdentifierPair type_ids_my_value; + ReturnCode_t return_code_my_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_value = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_byte", type_ids_color); + "_byte", type_ids_my_value); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_value) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + "my_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); return; } - StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_color = 0x00000000; - bool common_color_ec {false}; - CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; - if (!common_color_ec) + MemberId member_id_my_value = 0x00000000; + bool common_my_value_ec {false}; + CommonStructMember common_my_value {TypeObjectUtils::build_common_struct_member(member_id_my_value, member_flags_my_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_value, common_my_value_ec))}; + if (!common_my_value_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_value member TypeIdentifier inconsistent."); return; } - MemberName name_color = "color"; - eprosima::fastcdr::optional member_ann_builtin_color; + MemberName name_my_value = "my_value"; + eprosima::fastcdr::optional member_ann_builtin_my_value; ann_custom_MutableStruct.reset(); - CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_MutableStruct); - CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); - TypeObjectUtils::add_complete_struct_member(member_seq_MutableStruct, member_color); + CompleteMemberDetail detail_my_value = TypeObjectUtils::build_complete_member_detail(name_my_value, member_ann_builtin_my_value, ann_custom_MutableStruct); + CompleteStructMember member_my_value = TypeObjectUtils::build_complete_struct_member(common_my_value, detail_my_value); + TypeObjectUtils::add_complete_struct_member(member_seq_MutableStruct, member_my_value); } CompleteStructType struct_type_MutableStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_MutableStruct, header_MutableStruct, member_seq_MutableStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == @@ -191,34 +191,34 @@ void register_AppendableStruct_type_identifier( header_AppendableStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AppendableStruct); CompleteStructMemberSeq member_seq_AppendableStruct; { - TypeIdentifierPair type_ids_color; - ReturnCode_t return_code_color {eprosima::fastdds::dds::RETCODE_OK}; - return_code_color = + TypeIdentifierPair type_ids_my_value; + ReturnCode_t return_code_my_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_value = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_byte", type_ids_color); + "_byte", type_ids_my_value); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_color) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_value) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "color Structure member TypeIdentifier unknown to TypeObjectRegistry."); + "my_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); return; } - StructMemberFlag member_flags_color = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_color = 0x00000000; - bool common_color_ec {false}; - CommonStructMember common_color {TypeObjectUtils::build_common_struct_member(member_id_color, member_flags_color, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_color, common_color_ec))}; - if (!common_color_ec) + MemberId member_id_my_value = 0x00000000; + bool common_my_value_ec {false}; + CommonStructMember common_my_value {TypeObjectUtils::build_common_struct_member(member_id_my_value, member_flags_my_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_value, common_my_value_ec))}; + if (!common_my_value_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure color member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_value member TypeIdentifier inconsistent."); return; } - MemberName name_color = "color"; - eprosima::fastcdr::optional member_ann_builtin_color; + MemberName name_my_value = "my_value"; + eprosima::fastcdr::optional member_ann_builtin_my_value; ann_custom_AppendableStruct.reset(); - CompleteMemberDetail detail_color = TypeObjectUtils::build_complete_member_detail(name_color, member_ann_builtin_color, ann_custom_AppendableStruct); - CompleteStructMember member_color = TypeObjectUtils::build_complete_struct_member(common_color, detail_color); - TypeObjectUtils::add_complete_struct_member(member_seq_AppendableStruct, member_color); + CompleteMemberDetail detail_my_value = TypeObjectUtils::build_complete_member_detail(name_my_value, member_ann_builtin_my_value, ann_custom_AppendableStruct); + CompleteStructMember member_my_value = TypeObjectUtils::build_complete_struct_member(common_my_value, detail_my_value); + TypeObjectUtils::add_complete_struct_member(member_seq_AppendableStruct, member_my_value); } CompleteStructType struct_type_AppendableStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AppendableStruct, header_AppendableStruct, member_seq_AppendableStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == @@ -230,115 +230,115 @@ void register_AppendableStruct_type_identifier( } } // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_extensibility_struct_type_identifier( - TypeIdentifierPair& type_ids_extensibility_struct) +void register_ExtensibilityStruct_type_identifier( + TypeIdentifierPair& type_ids_ExtensibilityStruct) { - ReturnCode_t return_code_extensibility_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_extensibility_struct = + ReturnCode_t return_code_ExtensibilityStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ExtensibilityStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "extensibility_struct", type_ids_extensibility_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_extensibility_struct) + "ExtensibilityStruct", type_ids_ExtensibilityStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ExtensibilityStruct) { - StructTypeFlag struct_flags_extensibility_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_ExtensibilityStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_extensibility_struct = "extensibility_struct"; - eprosima::fastcdr::optional type_ann_builtin_extensibility_struct; - eprosima::fastcdr::optional ann_custom_extensibility_struct; - CompleteTypeDetail detail_extensibility_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_extensibility_struct, ann_custom_extensibility_struct, type_name_extensibility_struct.to_string()); - CompleteStructHeader header_extensibility_struct; - header_extensibility_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_extensibility_struct); - CompleteStructMemberSeq member_seq_extensibility_struct; + QualifiedTypeName type_name_ExtensibilityStruct = "ExtensibilityStruct"; + eprosima::fastcdr::optional type_ann_builtin_ExtensibilityStruct; + eprosima::fastcdr::optional ann_custom_ExtensibilityStruct; + CompleteTypeDetail detail_ExtensibilityStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ExtensibilityStruct, ann_custom_ExtensibilityStruct, type_name_ExtensibilityStruct.to_string()); + CompleteStructHeader header_ExtensibilityStruct; + header_ExtensibilityStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ExtensibilityStruct); + CompleteStructMemberSeq member_seq_ExtensibilityStruct; { - TypeIdentifierPair type_ids_red; - ReturnCode_t return_code_red {eprosima::fastdds::dds::RETCODE_OK}; - return_code_red = + TypeIdentifierPair type_ids_my_final_struct; + ReturnCode_t return_code_my_final_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_final_struct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FinalStruct", type_ids_red); + "FinalStruct", type_ids_my_final_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_red) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_final_struct) { - ::register_FinalStruct_type_identifier(type_ids_red); + ::register_FinalStruct_type_identifier(type_ids_my_final_struct); } - StructMemberFlag member_flags_red = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_final_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_red = 0x00000000; - bool common_red_ec {false}; - CommonStructMember common_red {TypeObjectUtils::build_common_struct_member(member_id_red, member_flags_red, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_red, common_red_ec))}; - if (!common_red_ec) + MemberId member_id_my_final_struct = 0x00000000; + bool common_my_final_struct_ec {false}; + CommonStructMember common_my_final_struct {TypeObjectUtils::build_common_struct_member(member_id_my_final_struct, member_flags_my_final_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_final_struct, common_my_final_struct_ec))}; + if (!common_my_final_struct_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure red member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_final_struct member TypeIdentifier inconsistent."); return; } - MemberName name_red = "red"; - eprosima::fastcdr::optional member_ann_builtin_red; - ann_custom_extensibility_struct.reset(); - CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_extensibility_struct); - CompleteStructMember member_red = TypeObjectUtils::build_complete_struct_member(common_red, detail_red); - TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_red); + MemberName name_my_final_struct = "my_final_struct"; + eprosima::fastcdr::optional member_ann_builtin_my_final_struct; + ann_custom_ExtensibilityStruct.reset(); + CompleteMemberDetail detail_my_final_struct = TypeObjectUtils::build_complete_member_detail(name_my_final_struct, member_ann_builtin_my_final_struct, ann_custom_ExtensibilityStruct); + CompleteStructMember member_my_final_struct = TypeObjectUtils::build_complete_struct_member(common_my_final_struct, detail_my_final_struct); + TypeObjectUtils::add_complete_struct_member(member_seq_ExtensibilityStruct, member_my_final_struct); } { - TypeIdentifierPair type_ids_blue; - ReturnCode_t return_code_blue {eprosima::fastdds::dds::RETCODE_OK}; - return_code_blue = + TypeIdentifierPair type_ids_my_mutable_struct; + ReturnCode_t return_code_my_mutable_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_mutable_struct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MutableStruct", type_ids_blue); + "MutableStruct", type_ids_my_mutable_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_blue) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_mutable_struct) { - ::register_MutableStruct_type_identifier(type_ids_blue); + ::register_MutableStruct_type_identifier(type_ids_my_mutable_struct); } - StructMemberFlag member_flags_blue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_mutable_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_blue = 0x00000001; - bool common_blue_ec {false}; - CommonStructMember common_blue {TypeObjectUtils::build_common_struct_member(member_id_blue, member_flags_blue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_blue, common_blue_ec))}; - if (!common_blue_ec) + MemberId member_id_my_mutable_struct = 0x00000001; + bool common_my_mutable_struct_ec {false}; + CommonStructMember common_my_mutable_struct {TypeObjectUtils::build_common_struct_member(member_id_my_mutable_struct, member_flags_my_mutable_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_mutable_struct, common_my_mutable_struct_ec))}; + if (!common_my_mutable_struct_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure blue member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_mutable_struct member TypeIdentifier inconsistent."); return; } - MemberName name_blue = "blue"; - eprosima::fastcdr::optional member_ann_builtin_blue; - ann_custom_extensibility_struct.reset(); - CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_extensibility_struct); - CompleteStructMember member_blue = TypeObjectUtils::build_complete_struct_member(common_blue, detail_blue); - TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_blue); + MemberName name_my_mutable_struct = "my_mutable_struct"; + eprosima::fastcdr::optional member_ann_builtin_my_mutable_struct; + ann_custom_ExtensibilityStruct.reset(); + CompleteMemberDetail detail_my_mutable_struct = TypeObjectUtils::build_complete_member_detail(name_my_mutable_struct, member_ann_builtin_my_mutable_struct, ann_custom_ExtensibilityStruct); + CompleteStructMember member_my_mutable_struct = TypeObjectUtils::build_complete_struct_member(common_my_mutable_struct, detail_my_mutable_struct); + TypeObjectUtils::add_complete_struct_member(member_seq_ExtensibilityStruct, member_my_mutable_struct); } { - TypeIdentifierPair type_ids_green; - ReturnCode_t return_code_green {eprosima::fastdds::dds::RETCODE_OK}; - return_code_green = + TypeIdentifierPair type_ids_my_appendable_struct; + ReturnCode_t return_code_my_appendable_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_appendable_struct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "AppendableStruct", type_ids_green); + "AppendableStruct", type_ids_my_appendable_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_green) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_appendable_struct) { - ::register_AppendableStruct_type_identifier(type_ids_green); + ::register_AppendableStruct_type_identifier(type_ids_my_appendable_struct); } - StructMemberFlag member_flags_green = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_appendable_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_green = 0x00000002; - bool common_green_ec {false}; - CommonStructMember common_green {TypeObjectUtils::build_common_struct_member(member_id_green, member_flags_green, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_green, common_green_ec))}; - if (!common_green_ec) + MemberId member_id_my_appendable_struct = 0x00000002; + bool common_my_appendable_struct_ec {false}; + CommonStructMember common_my_appendable_struct {TypeObjectUtils::build_common_struct_member(member_id_my_appendable_struct, member_flags_my_appendable_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_appendable_struct, common_my_appendable_struct_ec))}; + if (!common_my_appendable_struct_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure green member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_appendable_struct member TypeIdentifier inconsistent."); return; } - MemberName name_green = "green"; - eprosima::fastcdr::optional member_ann_builtin_green; - ann_custom_extensibility_struct.reset(); - CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_extensibility_struct); - CompleteStructMember member_green = TypeObjectUtils::build_complete_struct_member(common_green, detail_green); - TypeObjectUtils::add_complete_struct_member(member_seq_extensibility_struct, member_green); + MemberName name_my_appendable_struct = "my_appendable_struct"; + eprosima::fastcdr::optional member_ann_builtin_my_appendable_struct; + ann_custom_ExtensibilityStruct.reset(); + CompleteMemberDetail detail_my_appendable_struct = TypeObjectUtils::build_complete_member_detail(name_my_appendable_struct, member_ann_builtin_my_appendable_struct, ann_custom_ExtensibilityStruct); + CompleteStructMember member_my_appendable_struct = TypeObjectUtils::build_complete_struct_member(common_my_appendable_struct, detail_my_appendable_struct); + TypeObjectUtils::add_complete_struct_member(member_seq_ExtensibilityStruct, member_my_appendable_struct); } - CompleteStructType struct_type_extensibility_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_extensibility_struct, header_extensibility_struct, member_seq_extensibility_struct); + CompleteStructType struct_type_ExtensibilityStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ExtensibilityStruct, header_ExtensibilityStruct, member_seq_ExtensibilityStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_extensibility_struct, type_name_extensibility_struct.to_string(), type_ids_extensibility_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ExtensibilityStruct, type_name_ExtensibilityStruct.to_string(), type_ids_ExtensibilityStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "extensibility_struct already registered in TypeObjectRegistry for a different type."); + "ExtensibilityStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.hpp similarity index 96% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.hpp index b3a41baa9fc..7622fe245c8 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/extensibility_struct/extensibility_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/gen/extensibility_structTypeObjectSupport.hpp @@ -74,7 +74,7 @@ eProsima_user_DllExport void register_MutableStruct_type_identifier( eProsima_user_DllExport void register_AppendableStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register extensibility_struct related TypeIdentifier. + * @brief Register ExtensibilityStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -83,7 +83,7 @@ eProsima_user_DllExport void register_AppendableStruct_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_extensibility_struct_type_identifier( +eProsima_user_DllExport void register_ExtensibilityStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp deleted file mode 100644 index e94655a430f..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequences.hpp +++ /dev/null @@ -1,445 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file arrays_and_sequences.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_HPP -#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_HPP - -#include -#include -#include -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(ARRAYS_AND_SEQUENCES_SOURCE) -#define ARRAYS_AND_SEQUENCES_DllAPI __declspec( dllexport ) -#else -#define ARRAYS_AND_SEQUENCES_DllAPI __declspec( dllimport ) -#endif // ARRAYS_AND_SEQUENCES_SOURCE -#else -#define ARRAYS_AND_SEQUENCES_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define ARRAYS_AND_SEQUENCES_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure AnInternalObject defined by the user in the IDL file. - * @ingroup arrays_and_sequences - */ -class AnInternalObject -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport AnInternalObject() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~AnInternalObject() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object AnInternalObject that will be copied. - */ - eProsima_user_DllExport AnInternalObject( - const AnInternalObject& x) - { - m_x = x.m_x; - - m_positive = x.m_positive; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object AnInternalObject that will be copied. - */ - eProsima_user_DllExport AnInternalObject( - AnInternalObject&& x) noexcept - { - m_x = x.m_x; - m_positive = x.m_positive; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object AnInternalObject that will be copied. - */ - eProsima_user_DllExport AnInternalObject& operator =( - const AnInternalObject& x) - { - - m_x = x.m_x; - - m_positive = x.m_positive; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object AnInternalObject that will be copied. - */ - eProsima_user_DllExport AnInternalObject& operator =( - AnInternalObject&& x) noexcept - { - - m_x = x.m_x; - m_positive = x.m_positive; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x AnInternalObject object to compare. - */ - eProsima_user_DllExport bool operator ==( - const AnInternalObject& x) const - { - return (m_x == x.m_x && - m_positive == x.m_positive); - } - - /*! - * @brief Comparison operator. - * @param x AnInternalObject object to compare. - */ - eProsima_user_DllExport bool operator !=( - const AnInternalObject& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member x - * @param _x New value for member x - */ - eProsima_user_DllExport void x( - float _x) - { - m_x = _x; - } - - /*! - * @brief This function returns the value of member x - * @return Value of member x - */ - eProsima_user_DllExport float x() const - { - return m_x; - } - - /*! - * @brief This function returns a reference to member x - * @return Reference to member x - */ - eProsima_user_DllExport float& x() - { - return m_x; - } - - - /*! - * @brief This function sets a value in member positive - * @param _positive New value for member positive - */ - eProsima_user_DllExport void positive( - bool _positive) - { - m_positive = _positive; - } - - /*! - * @brief This function returns the value of member positive - * @return Value of member positive - */ - eProsima_user_DllExport bool positive() const - { - return m_positive; - } - - /*! - * @brief This function returns a reference to member positive - * @return Reference to member positive - */ - eProsima_user_DllExport bool& positive() - { - return m_positive; - } - - - -private: - - float m_x{0.0}; - bool m_positive{false}; - -}; -/*! - * @brief This class represents the structure arrays_and_sequences defined by the user in the IDL file. - * @ingroup arrays_and_sequences - */ -class arrays_and_sequences -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport arrays_and_sequences() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~arrays_and_sequences() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object arrays_and_sequences that will be copied. - */ - eProsima_user_DllExport arrays_and_sequences( - const arrays_and_sequences& x) - { - m_unlimited_vector = x.m_unlimited_vector; - - m_limited_vector = x.m_limited_vector; - - m_limited_array = x.m_limited_array; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object arrays_and_sequences that will be copied. - */ - eProsima_user_DllExport arrays_and_sequences( - arrays_and_sequences&& x) noexcept - { - m_unlimited_vector = std::move(x.m_unlimited_vector); - m_limited_vector = std::move(x.m_limited_vector); - m_limited_array = std::move(x.m_limited_array); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object arrays_and_sequences that will be copied. - */ - eProsima_user_DllExport arrays_and_sequences& operator =( - const arrays_and_sequences& x) - { - - m_unlimited_vector = x.m_unlimited_vector; - - m_limited_vector = x.m_limited_vector; - - m_limited_array = x.m_limited_array; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object arrays_and_sequences that will be copied. - */ - eProsima_user_DllExport arrays_and_sequences& operator =( - arrays_and_sequences&& x) noexcept - { - - m_unlimited_vector = std::move(x.m_unlimited_vector); - m_limited_vector = std::move(x.m_limited_vector); - m_limited_array = std::move(x.m_limited_array); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x arrays_and_sequences object to compare. - */ - eProsima_user_DllExport bool operator ==( - const arrays_and_sequences& x) const - { - return (m_unlimited_vector == x.m_unlimited_vector && - m_limited_vector == x.m_limited_vector && - m_limited_array == x.m_limited_array); - } - - /*! - * @brief Comparison operator. - * @param x arrays_and_sequences object to compare. - */ - eProsima_user_DllExport bool operator !=( - const arrays_and_sequences& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member unlimited_vector - * @param _unlimited_vector New value to be copied in member unlimited_vector - */ - eProsima_user_DllExport void unlimited_vector( - const std::vector& _unlimited_vector) - { - m_unlimited_vector = _unlimited_vector; - } - - /*! - * @brief This function moves the value in member unlimited_vector - * @param _unlimited_vector New value to be moved in member unlimited_vector - */ - eProsima_user_DllExport void unlimited_vector( - std::vector&& _unlimited_vector) - { - m_unlimited_vector = std::move(_unlimited_vector); - } - - /*! - * @brief This function returns a constant reference to member unlimited_vector - * @return Constant reference to member unlimited_vector - */ - eProsima_user_DllExport const std::vector& unlimited_vector() const - { - return m_unlimited_vector; - } - - /*! - * @brief This function returns a reference to member unlimited_vector - * @return Reference to member unlimited_vector - */ - eProsima_user_DllExport std::vector& unlimited_vector() - { - return m_unlimited_vector; - } - - - /*! - * @brief This function copies the value in member limited_vector - * @param _limited_vector New value to be copied in member limited_vector - */ - eProsima_user_DllExport void limited_vector( - const std::vector& _limited_vector) - { - m_limited_vector = _limited_vector; - } - - /*! - * @brief This function moves the value in member limited_vector - * @param _limited_vector New value to be moved in member limited_vector - */ - eProsima_user_DllExport void limited_vector( - std::vector&& _limited_vector) - { - m_limited_vector = std::move(_limited_vector); - } - - /*! - * @brief This function returns a constant reference to member limited_vector - * @return Constant reference to member limited_vector - */ - eProsima_user_DllExport const std::vector& limited_vector() const - { - return m_limited_vector; - } - - /*! - * @brief This function returns a reference to member limited_vector - * @return Reference to member limited_vector - */ - eProsima_user_DllExport std::vector& limited_vector() - { - return m_limited_vector; - } - - - /*! - * @brief This function copies the value in member limited_array - * @param _limited_array New value to be copied in member limited_array - */ - eProsima_user_DllExport void limited_array( - const std::array& _limited_array) - { - m_limited_array = _limited_array; - } - - /*! - * @brief This function moves the value in member limited_array - * @param _limited_array New value to be moved in member limited_array - */ - eProsima_user_DllExport void limited_array( - std::array&& _limited_array) - { - m_limited_array = std::move(_limited_array); - } - - /*! - * @brief This function returns a constant reference to member limited_array - * @return Constant reference to member limited_array - */ - eProsima_user_DllExport const std::array& limited_array() const - { - return m_limited_array; - } - - /*! - * @brief This function returns a reference to member limited_array - * @return Reference to member limited_array - */ - eProsima_user_DllExport std::array& limited_array() - { - return m_limited_array; - } - - - -private: - - std::vector m_unlimited_vector; - std::vector m_limited_vector; - std::array m_limited_array; - -}; - -#endif // _FAST_DDS_GENERATED_ARRAYS_AND_SEQUENCES_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx deleted file mode 100644 index cd805263983..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.cxx +++ /dev/null @@ -1,422 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file arrays_and_sequencesPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "arrays_and_sequencesPubSubTypes.hpp" - -#include -#include - -#include "arrays_and_sequencesCdrAux.hpp" -#include "arrays_and_sequencesTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -AnInternalObjectPubSubType::AnInternalObjectPubSubType() -{ - setName("AnInternalObject"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(AnInternalObject::getMaxCdrSerializedSize()); -#else - AnInternalObject_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = AnInternalObject_max_key_cdr_typesize > 16 ? AnInternalObject_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -AnInternalObjectPubSubType::~AnInternalObjectPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool AnInternalObjectPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const AnInternalObject* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool AnInternalObjectPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - AnInternalObject* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function AnInternalObjectPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* AnInternalObjectPubSubType::createData() -{ - return reinterpret_cast(new AnInternalObject()); -} - -void AnInternalObjectPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool AnInternalObjectPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const AnInternalObject* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - AnInternalObject_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || AnInternalObject_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void AnInternalObjectPubSubType::register_type_object_representation() -{ - register_AnInternalObject_type_identifier(type_identifiers_); -} - -arrays_and_sequencesPubSubType::arrays_and_sequencesPubSubType() -{ - setName("arrays_and_sequences"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(arrays_and_sequences::getMaxCdrSerializedSize()); -#else - arrays_and_sequences_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = arrays_and_sequences_max_key_cdr_typesize > 16 ? arrays_and_sequences_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -arrays_and_sequencesPubSubType::~arrays_and_sequencesPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool arrays_and_sequencesPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const arrays_and_sequences* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool arrays_and_sequencesPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - arrays_and_sequences* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function arrays_and_sequencesPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* arrays_and_sequencesPubSubType::createData() -{ - return reinterpret_cast(new arrays_and_sequences()); -} - -void arrays_and_sequencesPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool arrays_and_sequencesPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const arrays_and_sequences* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - arrays_and_sequences_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || arrays_and_sequences_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void arrays_and_sequencesPubSubType::register_type_object_representation() -{ - register_arrays_and_sequences_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "arrays_and_sequencesCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp deleted file mode 100644 index 4b3677a405a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesPubSubTypes.hpp +++ /dev/null @@ -1,224 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file arrays_and_sequencesPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "arrays_and_sequences.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated arrays_and_sequences is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type AnInternalObject defined by the user in the IDL file. - * @ingroup arrays_and_sequences - */ -class AnInternalObjectPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef AnInternalObject type; - - eProsima_user_DllExport AnInternalObjectPubSubType(); - - eProsima_user_DllExport ~AnInternalObjectPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type arrays_and_sequences defined by the user in the IDL file. - * @ingroup arrays_and_sequences - */ -class arrays_and_sequencesPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef arrays_and_sequences type; - - eProsima_user_DllExport arrays_and_sequencesPubSubType(); - - eProsima_user_DllExport ~arrays_and_sequencesPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx deleted file mode 100644 index 06defd218d6..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.cxx +++ /dev/null @@ -1,341 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file arrays_and_sequencesTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "arrays_and_sequencesTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "arrays_and_sequences.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_AnInternalObject_type_identifier( - TypeIdentifierPair& type_ids_AnInternalObject) -{ - - ReturnCode_t return_code_AnInternalObject {eprosima::fastdds::dds::RETCODE_OK}; - return_code_AnInternalObject = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "AnInternalObject", type_ids_AnInternalObject); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_AnInternalObject) - { - StructTypeFlag struct_flags_AnInternalObject = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_AnInternalObject = "AnInternalObject"; - eprosima::fastcdr::optional type_ann_builtin_AnInternalObject; - eprosima::fastcdr::optional ann_custom_AnInternalObject; - CompleteTypeDetail detail_AnInternalObject = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_AnInternalObject, ann_custom_AnInternalObject, type_name_AnInternalObject.to_string()); - CompleteStructHeader header_AnInternalObject; - header_AnInternalObject = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AnInternalObject); - CompleteStructMemberSeq member_seq_AnInternalObject; - { - TypeIdentifierPair type_ids_x; - ReturnCode_t return_code_x {eprosima::fastdds::dds::RETCODE_OK}; - return_code_x = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_float", type_ids_x); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_x) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "x Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_x = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_x = 0x00000000; - bool common_x_ec {false}; - CommonStructMember common_x {TypeObjectUtils::build_common_struct_member(member_id_x, member_flags_x, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x, common_x_ec))}; - if (!common_x_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x member TypeIdentifier inconsistent."); - return; - } - MemberName name_x = "x"; - eprosima::fastcdr::optional member_ann_builtin_x; - ann_custom_AnInternalObject.reset(); - CompleteMemberDetail detail_x = TypeObjectUtils::build_complete_member_detail(name_x, member_ann_builtin_x, ann_custom_AnInternalObject); - CompleteStructMember member_x = TypeObjectUtils::build_complete_struct_member(common_x, detail_x); - TypeObjectUtils::add_complete_struct_member(member_seq_AnInternalObject, member_x); - } - { - TypeIdentifierPair type_ids_positive; - ReturnCode_t return_code_positive {eprosima::fastdds::dds::RETCODE_OK}; - return_code_positive = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_bool", type_ids_positive); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_positive) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "positive Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_positive = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_positive = 0x00000001; - bool common_positive_ec {false}; - CommonStructMember common_positive {TypeObjectUtils::build_common_struct_member(member_id_positive, member_flags_positive, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_positive, common_positive_ec))}; - if (!common_positive_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure positive member TypeIdentifier inconsistent."); - return; - } - MemberName name_positive = "positive"; - eprosima::fastcdr::optional member_ann_builtin_positive; - ann_custom_AnInternalObject.reset(); - CompleteMemberDetail detail_positive = TypeObjectUtils::build_complete_member_detail(name_positive, member_ann_builtin_positive, ann_custom_AnInternalObject); - CompleteStructMember member_positive = TypeObjectUtils::build_complete_struct_member(common_positive, detail_positive); - TypeObjectUtils::add_complete_struct_member(member_seq_AnInternalObject, member_positive); - } - CompleteStructType struct_type_AnInternalObject = TypeObjectUtils::build_complete_struct_type(struct_flags_AnInternalObject, header_AnInternalObject, member_seq_AnInternalObject); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_AnInternalObject, type_name_AnInternalObject.to_string(), type_ids_AnInternalObject)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "AnInternalObject already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_arrays_and_sequences_type_identifier( - TypeIdentifierPair& type_ids_arrays_and_sequences) -{ - - ReturnCode_t return_code_arrays_and_sequences {eprosima::fastdds::dds::RETCODE_OK}; - return_code_arrays_and_sequences = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "arrays_and_sequences", type_ids_arrays_and_sequences); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_arrays_and_sequences) - { - StructTypeFlag struct_flags_arrays_and_sequences = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_arrays_and_sequences = "arrays_and_sequences"; - eprosima::fastcdr::optional type_ann_builtin_arrays_and_sequences; - eprosima::fastcdr::optional ann_custom_arrays_and_sequences; - CompleteTypeDetail detail_arrays_and_sequences = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_arrays_and_sequences, ann_custom_arrays_and_sequences, type_name_arrays_and_sequences.to_string()); - CompleteStructHeader header_arrays_and_sequences; - header_arrays_and_sequences = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_arrays_and_sequences); - CompleteStructMemberSeq member_seq_arrays_and_sequences; - { - TypeIdentifierPair type_ids_unlimited_vector; - ReturnCode_t return_code_unlimited_vector {eprosima::fastdds::dds::RETCODE_OK}; - return_code_unlimited_vector = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_AnInternalObject_unbounded", type_ids_unlimited_vector); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_unlimited_vector) - { - return_code_unlimited_vector = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "AnInternalObject", type_ids_unlimited_vector); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_unlimited_vector) - { - ::register_AnInternalObject_type_identifier(type_ids_unlimited_vector); - } - bool element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_AnInternalObject_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unlimited_vector, element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec))}; - if (!element_identifier_anonymous_sequence_AnInternalObject_unbounded_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_AnInternalObject_unbounded = EK_COMPLETE; - if (TK_NONE == type_ids_unlimited_vector.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_AnInternalObject_unbounded = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_AnInternalObject_unbounded = 0; - PlainCollectionHeader header_anonymous_sequence_AnInternalObject_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_AnInternalObject_unbounded, element_flags_anonymous_sequence_AnInternalObject_unbounded); - { - SBound bound = 0; - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_AnInternalObject_unbounded, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_AnInternalObject_unbounded)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_AnInternalObject_unbounded", type_ids_unlimited_vector)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_AnInternalObject_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_unlimited_vector = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_unlimited_vector = 0x00000000; - bool common_unlimited_vector_ec {false}; - CommonStructMember common_unlimited_vector {TypeObjectUtils::build_common_struct_member(member_id_unlimited_vector, member_flags_unlimited_vector, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_unlimited_vector, common_unlimited_vector_ec))}; - if (!common_unlimited_vector_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure unlimited_vector member TypeIdentifier inconsistent."); - return; - } - MemberName name_unlimited_vector = "unlimited_vector"; - eprosima::fastcdr::optional member_ann_builtin_unlimited_vector; - ann_custom_arrays_and_sequences.reset(); - CompleteMemberDetail detail_unlimited_vector = TypeObjectUtils::build_complete_member_detail(name_unlimited_vector, member_ann_builtin_unlimited_vector, ann_custom_arrays_and_sequences); - CompleteStructMember member_unlimited_vector = TypeObjectUtils::build_complete_struct_member(common_unlimited_vector, detail_unlimited_vector); - TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_unlimited_vector); - } - { - TypeIdentifierPair type_ids_limited_vector; - ReturnCode_t return_code_limited_vector {eprosima::fastdds::dds::RETCODE_OK}; - return_code_limited_vector = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_AnInternalObject_10", type_ids_limited_vector); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_vector) - { - return_code_limited_vector = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "AnInternalObject", type_ids_limited_vector); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_vector) - { - ::register_AnInternalObject_type_identifier(type_ids_limited_vector); - } - bool element_identifier_anonymous_sequence_AnInternalObject_10_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_AnInternalObject_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_vector, element_identifier_anonymous_sequence_AnInternalObject_10_ec))}; - if (!element_identifier_anonymous_sequence_AnInternalObject_10_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_AnInternalObject_10 = EK_COMPLETE; - if (TK_NONE == type_ids_limited_vector.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_AnInternalObject_10 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_AnInternalObject_10 = 0; - PlainCollectionHeader header_anonymous_sequence_AnInternalObject_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_AnInternalObject_10, element_flags_anonymous_sequence_AnInternalObject_10); - { - SBound bound = static_cast(10); - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_AnInternalObject_10, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_AnInternalObject_10)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_AnInternalObject_10", type_ids_limited_vector)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_AnInternalObject_10 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_limited_vector = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_limited_vector = 0x00000001; - bool common_limited_vector_ec {false}; - CommonStructMember common_limited_vector {TypeObjectUtils::build_common_struct_member(member_id_limited_vector, member_flags_limited_vector, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_vector, common_limited_vector_ec))}; - if (!common_limited_vector_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure limited_vector member TypeIdentifier inconsistent."); - return; - } - MemberName name_limited_vector = "limited_vector"; - eprosima::fastcdr::optional member_ann_builtin_limited_vector; - ann_custom_arrays_and_sequences.reset(); - CompleteMemberDetail detail_limited_vector = TypeObjectUtils::build_complete_member_detail(name_limited_vector, member_ann_builtin_limited_vector, ann_custom_arrays_and_sequences); - CompleteStructMember member_limited_vector = TypeObjectUtils::build_complete_struct_member(common_limited_vector, detail_limited_vector); - TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_limited_vector); - } - { - TypeIdentifierPair type_ids_limited_array; - ReturnCode_t return_code_limited_array {eprosima::fastdds::dds::RETCODE_OK}; - return_code_limited_array = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_array_AnInternalObject_10", type_ids_limited_array); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_array) - { - return_code_limited_array = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "AnInternalObject", type_ids_limited_array); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_limited_array) - { - ::register_AnInternalObject_type_identifier(type_ids_limited_array); - } - bool element_identifier_anonymous_array_AnInternalObject_10_ec {false}; - TypeIdentifier* element_identifier_anonymous_array_AnInternalObject_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_array, element_identifier_anonymous_array_AnInternalObject_10_ec))}; - if (!element_identifier_anonymous_array_AnInternalObject_10_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_array_AnInternalObject_10 = EK_COMPLETE; - if (TK_NONE == type_ids_limited_array.type_identifier2()._d()) - { - equiv_kind_anonymous_array_AnInternalObject_10 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_array_AnInternalObject_10 = 0; - PlainCollectionHeader header_anonymous_array_AnInternalObject_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_AnInternalObject_10, element_flags_anonymous_array_AnInternalObject_10); - { - SBoundSeq array_bound_seq; - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(10)); - - PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_AnInternalObject_10, array_bound_seq, - eprosima::fastcdr::external(element_identifier_anonymous_array_AnInternalObject_10)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_AnInternalObject_10", type_ids_limited_array)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_array_AnInternalObject_10 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_limited_array = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_limited_array = 0x00000002; - bool common_limited_array_ec {false}; - CommonStructMember common_limited_array {TypeObjectUtils::build_common_struct_member(member_id_limited_array, member_flags_limited_array, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_limited_array, common_limited_array_ec))}; - if (!common_limited_array_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure limited_array member TypeIdentifier inconsistent."); - return; - } - MemberName name_limited_array = "limited_array"; - eprosima::fastcdr::optional member_ann_builtin_limited_array; - ann_custom_arrays_and_sequences.reset(); - CompleteMemberDetail detail_limited_array = TypeObjectUtils::build_complete_member_detail(name_limited_array, member_ann_builtin_limited_array, ann_custom_arrays_and_sequences); - CompleteStructMember member_limited_array = TypeObjectUtils::build_complete_struct_member(common_limited_array, detail_limited_array); - TypeObjectUtils::add_complete_struct_member(member_seq_arrays_and_sequences, member_limited_array); - } - CompleteStructType struct_type_arrays_and_sequences = TypeObjectUtils::build_complete_struct_type(struct_flags_arrays_and_sequences, header_arrays_and_sequences, member_seq_arrays_and_sequences); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_arrays_and_sequences, type_name_arrays_and_sequences.to_string(), type_ids_arrays_and_sequences)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "arrays_and_sequences already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp deleted file mode 100644 index 43f145f3861..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesTypeObjectSupport.hpp +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file arrays_and_sequencesTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register AnInternalObject related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_AnInternalObject_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register arrays_and_sequences related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_arrays_and_sequences_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCES_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp deleted file mode 100644 index 1352a2e4120..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_struct.hpp +++ /dev/null @@ -1,386 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_array_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_HPP -#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_HPP - -#include -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(BASIC_ARRAY_STRUCT_SOURCE) -#define BASIC_ARRAY_STRUCT_DllAPI __declspec( dllexport ) -#else -#define BASIC_ARRAY_STRUCT_DllAPI __declspec( dllimport ) -#endif // BASIC_ARRAY_STRUCT_SOURCE -#else -#define BASIC_ARRAY_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define BASIC_ARRAY_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure TheOtherObjectInArray defined by the user in the IDL file. - * @ingroup basic_array_struct - */ -class TheOtherObjectInArray -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport TheOtherObjectInArray() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~TheOtherObjectInArray() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object TheOtherObjectInArray that will be copied. - */ - eProsima_user_DllExport TheOtherObjectInArray( - const TheOtherObjectInArray& x) - { - m_some_num = x.m_some_num; - - m_positive = x.m_positive; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object TheOtherObjectInArray that will be copied. - */ - eProsima_user_DllExport TheOtherObjectInArray( - TheOtherObjectInArray&& x) noexcept - { - m_some_num = x.m_some_num; - m_positive = x.m_positive; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object TheOtherObjectInArray that will be copied. - */ - eProsima_user_DllExport TheOtherObjectInArray& operator =( - const TheOtherObjectInArray& x) - { - - m_some_num = x.m_some_num; - - m_positive = x.m_positive; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object TheOtherObjectInArray that will be copied. - */ - eProsima_user_DllExport TheOtherObjectInArray& operator =( - TheOtherObjectInArray&& x) noexcept - { - - m_some_num = x.m_some_num; - m_positive = x.m_positive; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x TheOtherObjectInArray object to compare. - */ - eProsima_user_DllExport bool operator ==( - const TheOtherObjectInArray& x) const - { - return (m_some_num == x.m_some_num && - m_positive == x.m_positive); - } - - /*! - * @brief Comparison operator. - * @param x TheOtherObjectInArray object to compare. - */ - eProsima_user_DllExport bool operator !=( - const TheOtherObjectInArray& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member some_num - * @param _some_num New value for member some_num - */ - eProsima_user_DllExport void some_num( - int32_t _some_num) - { - m_some_num = _some_num; - } - - /*! - * @brief This function returns the value of member some_num - * @return Value of member some_num - */ - eProsima_user_DllExport int32_t some_num() const - { - return m_some_num; - } - - /*! - * @brief This function returns a reference to member some_num - * @return Reference to member some_num - */ - eProsima_user_DllExport int32_t& some_num() - { - return m_some_num; - } - - - /*! - * @brief This function sets a value in member positive - * @param _positive New value for member positive - */ - eProsima_user_DllExport void positive( - bool _positive) - { - m_positive = _positive; - } - - /*! - * @brief This function returns the value of member positive - * @return Value of member positive - */ - eProsima_user_DllExport bool positive() const - { - return m_positive; - } - - /*! - * @brief This function returns a reference to member positive - * @return Reference to member positive - */ - eProsima_user_DllExport bool& positive() - { - return m_positive; - } - - - -private: - - int32_t m_some_num{0}; - bool m_positive{false}; - -}; -/*! - * @brief This class represents the structure basic_array_struct defined by the user in the IDL file. - * @ingroup basic_array_struct - */ -class basic_array_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport basic_array_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~basic_array_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object basic_array_struct that will be copied. - */ - eProsima_user_DllExport basic_array_struct( - const basic_array_struct& x) - { - m_index = x.m_index; - - m_sub_structs = x.m_sub_structs; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object basic_array_struct that will be copied. - */ - eProsima_user_DllExport basic_array_struct( - basic_array_struct&& x) noexcept - { - m_index = x.m_index; - m_sub_structs = std::move(x.m_sub_structs); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object basic_array_struct that will be copied. - */ - eProsima_user_DllExport basic_array_struct& operator =( - const basic_array_struct& x) - { - - m_index = x.m_index; - - m_sub_structs = x.m_sub_structs; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object basic_array_struct that will be copied. - */ - eProsima_user_DllExport basic_array_struct& operator =( - basic_array_struct&& x) noexcept - { - - m_index = x.m_index; - m_sub_structs = std::move(x.m_sub_structs); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x basic_array_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const basic_array_struct& x) const - { - return (m_index == x.m_index && - m_sub_structs == x.m_sub_structs); - } - - /*! - * @brief Comparison operator. - * @param x basic_array_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const basic_array_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member index - * @param _index New value for member index - */ - eProsima_user_DllExport void index( - uint32_t _index) - { - m_index = _index; - } - - /*! - * @brief This function returns the value of member index - * @return Value of member index - */ - eProsima_user_DllExport uint32_t index() const - { - return m_index; - } - - /*! - * @brief This function returns a reference to member index - * @return Reference to member index - */ - eProsima_user_DllExport uint32_t& index() - { - return m_index; - } - - - /*! - * @brief This function copies the value in member sub_structs - * @param _sub_structs New value to be copied in member sub_structs - */ - eProsima_user_DllExport void sub_structs( - const std::array& _sub_structs) - { - m_sub_structs = _sub_structs; - } - - /*! - * @brief This function moves the value in member sub_structs - * @param _sub_structs New value to be moved in member sub_structs - */ - eProsima_user_DllExport void sub_structs( - std::array&& _sub_structs) - { - m_sub_structs = std::move(_sub_structs); - } - - /*! - * @brief This function returns a constant reference to member sub_structs - * @return Constant reference to member sub_structs - */ - eProsima_user_DllExport const std::array& sub_structs() const - { - return m_sub_structs; - } - - /*! - * @brief This function returns a reference to member sub_structs - * @return Reference to member sub_structs - */ - eProsima_user_DllExport std::array& sub_structs() - { - return m_sub_structs; - } - - - -private: - - uint32_t m_index{0}; - std::array m_sub_structs; - -}; - -#endif // _FAST_DDS_GENERATED_BASIC_ARRAY_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx deleted file mode 100644 index 242ea8119a4..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.cxx +++ /dev/null @@ -1,251 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_array_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "basic_array_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "basic_array_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_TheOtherObjectInArray_type_identifier( - TypeIdentifierPair& type_ids_TheOtherObjectInArray) -{ - - ReturnCode_t return_code_TheOtherObjectInArray {eprosima::fastdds::dds::RETCODE_OK}; - return_code_TheOtherObjectInArray = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "TheOtherObjectInArray", type_ids_TheOtherObjectInArray); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_TheOtherObjectInArray) - { - StructTypeFlag struct_flags_TheOtherObjectInArray = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_TheOtherObjectInArray = "TheOtherObjectInArray"; - eprosima::fastcdr::optional type_ann_builtin_TheOtherObjectInArray; - eprosima::fastcdr::optional ann_custom_TheOtherObjectInArray; - CompleteTypeDetail detail_TheOtherObjectInArray = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_TheOtherObjectInArray, ann_custom_TheOtherObjectInArray, type_name_TheOtherObjectInArray.to_string()); - CompleteStructHeader header_TheOtherObjectInArray; - header_TheOtherObjectInArray = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_TheOtherObjectInArray); - CompleteStructMemberSeq member_seq_TheOtherObjectInArray; - { - TypeIdentifierPair type_ids_some_num; - ReturnCode_t return_code_some_num {eprosima::fastdds::dds::RETCODE_OK}; - return_code_some_num = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_some_num); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_some_num) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "some_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_some_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_some_num = 0x00000000; - bool common_some_num_ec {false}; - CommonStructMember common_some_num {TypeObjectUtils::build_common_struct_member(member_id_some_num, member_flags_some_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_some_num, common_some_num_ec))}; - if (!common_some_num_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure some_num member TypeIdentifier inconsistent."); - return; - } - MemberName name_some_num = "some_num"; - eprosima::fastcdr::optional member_ann_builtin_some_num; - ann_custom_TheOtherObjectInArray.reset(); - CompleteMemberDetail detail_some_num = TypeObjectUtils::build_complete_member_detail(name_some_num, member_ann_builtin_some_num, ann_custom_TheOtherObjectInArray); - CompleteStructMember member_some_num = TypeObjectUtils::build_complete_struct_member(common_some_num, detail_some_num); - TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObjectInArray, member_some_num); - } - { - TypeIdentifierPair type_ids_positive; - ReturnCode_t return_code_positive {eprosima::fastdds::dds::RETCODE_OK}; - return_code_positive = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_bool", type_ids_positive); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_positive) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "positive Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_positive = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_positive = 0x00000001; - bool common_positive_ec {false}; - CommonStructMember common_positive {TypeObjectUtils::build_common_struct_member(member_id_positive, member_flags_positive, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_positive, common_positive_ec))}; - if (!common_positive_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure positive member TypeIdentifier inconsistent."); - return; - } - MemberName name_positive = "positive"; - eprosima::fastcdr::optional member_ann_builtin_positive; - ann_custom_TheOtherObjectInArray.reset(); - CompleteMemberDetail detail_positive = TypeObjectUtils::build_complete_member_detail(name_positive, member_ann_builtin_positive, ann_custom_TheOtherObjectInArray); - CompleteStructMember member_positive = TypeObjectUtils::build_complete_struct_member(common_positive, detail_positive); - TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObjectInArray, member_positive); - } - CompleteStructType struct_type_TheOtherObjectInArray = TypeObjectUtils::build_complete_struct_type(struct_flags_TheOtherObjectInArray, header_TheOtherObjectInArray, member_seq_TheOtherObjectInArray); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_TheOtherObjectInArray, type_name_TheOtherObjectInArray.to_string(), type_ids_TheOtherObjectInArray)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "TheOtherObjectInArray already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_basic_array_struct_type_identifier( - TypeIdentifierPair& type_ids_basic_array_struct) -{ - - ReturnCode_t return_code_basic_array_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_basic_array_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "basic_array_struct", type_ids_basic_array_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_basic_array_struct) - { - StructTypeFlag struct_flags_basic_array_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_basic_array_struct = "basic_array_struct"; - eprosima::fastcdr::optional type_ann_builtin_basic_array_struct; - eprosima::fastcdr::optional ann_custom_basic_array_struct; - CompleteTypeDetail detail_basic_array_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_basic_array_struct, ann_custom_basic_array_struct, type_name_basic_array_struct.to_string()); - CompleteStructHeader header_basic_array_struct; - header_basic_array_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_basic_array_struct); - CompleteStructMemberSeq member_seq_basic_array_struct; - { - TypeIdentifierPair type_ids_index; - ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; - return_code_index = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint32_t", type_ids_index); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_index = 0x00000000; - bool common_index_ec {false}; - CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; - if (!common_index_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); - return; - } - MemberName name_index = "index"; - eprosima::fastcdr::optional member_ann_builtin_index; - ann_custom_basic_array_struct.reset(); - CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_basic_array_struct); - CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); - TypeObjectUtils::add_complete_struct_member(member_seq_basic_array_struct, member_index); - } - { - TypeIdentifierPair type_ids_sub_structs; - ReturnCode_t return_code_sub_structs {eprosima::fastdds::dds::RETCODE_OK}; - return_code_sub_structs = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_array_TheOtherObjectInArray_5", type_ids_sub_structs); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_structs) - { - return_code_sub_structs = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "TheOtherObjectInArray", type_ids_sub_structs); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_structs) - { - ::register_TheOtherObjectInArray_type_identifier(type_ids_sub_structs); - } - bool element_identifier_anonymous_array_TheOtherObjectInArray_5_ec {false}; - TypeIdentifier* element_identifier_anonymous_array_TheOtherObjectInArray_5 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_structs, element_identifier_anonymous_array_TheOtherObjectInArray_5_ec))}; - if (!element_identifier_anonymous_array_TheOtherObjectInArray_5_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_array_TheOtherObjectInArray_5 = EK_COMPLETE; - if (TK_NONE == type_ids_sub_structs.type_identifier2()._d()) - { - equiv_kind_anonymous_array_TheOtherObjectInArray_5 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_array_TheOtherObjectInArray_5 = 0; - PlainCollectionHeader header_anonymous_array_TheOtherObjectInArray_5 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_TheOtherObjectInArray_5, element_flags_anonymous_array_TheOtherObjectInArray_5); - { - SBoundSeq array_bound_seq; - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); - - PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_TheOtherObjectInArray_5, array_bound_seq, - eprosima::fastcdr::external(element_identifier_anonymous_array_TheOtherObjectInArray_5)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_TheOtherObjectInArray_5", type_ids_sub_structs)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_array_TheOtherObjectInArray_5 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_sub_structs = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_sub_structs = 0x00000001; - bool common_sub_structs_ec {false}; - CommonStructMember common_sub_structs {TypeObjectUtils::build_common_struct_member(member_id_sub_structs, member_flags_sub_structs, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_structs, common_sub_structs_ec))}; - if (!common_sub_structs_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub_structs member TypeIdentifier inconsistent."); - return; - } - MemberName name_sub_structs = "sub_structs"; - eprosima::fastcdr::optional member_ann_builtin_sub_structs; - ann_custom_basic_array_struct.reset(); - CompleteMemberDetail detail_sub_structs = TypeObjectUtils::build_complete_member_detail(name_sub_structs, member_ann_builtin_sub_structs, ann_custom_basic_array_struct); - CompleteStructMember member_sub_structs = TypeObjectUtils::build_complete_struct_member(common_sub_structs, detail_sub_structs); - TypeObjectUtils::add_complete_struct_member(member_seq_basic_array_struct, member_sub_structs); - } - CompleteStructType struct_type_basic_array_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_basic_array_struct, header_basic_array_struct, member_seq_basic_array_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_basic_array_struct, type_name_basic_array_struct.to_string(), type_ids_basic_array_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "basic_array_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp deleted file mode 100644 index 9ba4805a4d8..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_struct.hpp +++ /dev/null @@ -1,311 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_HPP -#define FAST_DDS_GENERATED__BASIC_STRUCT_HPP - -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(BASIC_STRUCT_SOURCE) -#define BASIC_STRUCT_DllAPI __declspec( dllexport ) -#else -#define BASIC_STRUCT_DllAPI __declspec( dllimport ) -#endif // BASIC_STRUCT_SOURCE -#else -#define BASIC_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define BASIC_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure TheOtherObject defined by the user in the IDL file. - * @ingroup basic_struct - */ -class TheOtherObject -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport TheOtherObject() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~TheOtherObject() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object TheOtherObject that will be copied. - */ - eProsima_user_DllExport TheOtherObject( - const TheOtherObject& x) - { - m_some_num = x.m_some_num; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object TheOtherObject that will be copied. - */ - eProsima_user_DllExport TheOtherObject( - TheOtherObject&& x) noexcept - { - m_some_num = x.m_some_num; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object TheOtherObject that will be copied. - */ - eProsima_user_DllExport TheOtherObject& operator =( - const TheOtherObject& x) - { - - m_some_num = x.m_some_num; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object TheOtherObject that will be copied. - */ - eProsima_user_DllExport TheOtherObject& operator =( - TheOtherObject&& x) noexcept - { - - m_some_num = x.m_some_num; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x TheOtherObject object to compare. - */ - eProsima_user_DllExport bool operator ==( - const TheOtherObject& x) const - { - return (m_some_num == x.m_some_num); - } - - /*! - * @brief Comparison operator. - * @param x TheOtherObject object to compare. - */ - eProsima_user_DllExport bool operator !=( - const TheOtherObject& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member some_num - * @param _some_num New value for member some_num - */ - eProsima_user_DllExport void some_num( - int32_t _some_num) - { - m_some_num = _some_num; - } - - /*! - * @brief This function returns the value of member some_num - * @return Value of member some_num - */ - eProsima_user_DllExport int32_t some_num() const - { - return m_some_num; - } - - /*! - * @brief This function returns a reference to member some_num - * @return Reference to member some_num - */ - eProsima_user_DllExport int32_t& some_num() - { - return m_some_num; - } - - - -private: - - int32_t m_some_num{0}; - -}; -/*! - * @brief This class represents the structure basic_struct defined by the user in the IDL file. - * @ingroup basic_struct - */ -class basic_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport basic_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~basic_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object basic_struct that will be copied. - */ - eProsima_user_DllExport basic_struct( - const basic_struct& x) - { - m_sub_struct = x.m_sub_struct; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object basic_struct that will be copied. - */ - eProsima_user_DllExport basic_struct( - basic_struct&& x) noexcept - { - m_sub_struct = std::move(x.m_sub_struct); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object basic_struct that will be copied. - */ - eProsima_user_DllExport basic_struct& operator =( - const basic_struct& x) - { - - m_sub_struct = x.m_sub_struct; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object basic_struct that will be copied. - */ - eProsima_user_DllExport basic_struct& operator =( - basic_struct&& x) noexcept - { - - m_sub_struct = std::move(x.m_sub_struct); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x basic_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const basic_struct& x) const - { - return (m_sub_struct == x.m_sub_struct); - } - - /*! - * @brief Comparison operator. - * @param x basic_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const basic_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member sub_struct - * @param _sub_struct New value to be copied in member sub_struct - */ - eProsima_user_DllExport void sub_struct( - const TheOtherObject& _sub_struct) - { - m_sub_struct = _sub_struct; - } - - /*! - * @brief This function moves the value in member sub_struct - * @param _sub_struct New value to be moved in member sub_struct - */ - eProsima_user_DllExport void sub_struct( - TheOtherObject&& _sub_struct) - { - m_sub_struct = std::move(_sub_struct); - } - - /*! - * @brief This function returns a constant reference to member sub_struct - * @return Constant reference to member sub_struct - */ - eProsima_user_DllExport const TheOtherObject& sub_struct() const - { - return m_sub_struct; - } - - /*! - * @brief This function returns a reference to member sub_struct - * @return Reference to member sub_struct - */ - eProsima_user_DllExport TheOtherObject& sub_struct() - { - return m_sub_struct; - } - - - -private: - - TheOtherObject m_sub_struct; - -}; - -#endif // _FAST_DDS_GENERATED_BASIC_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp deleted file mode 100644 index ac32e369114..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_structCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP - -#include "basic_struct.hpp" - -constexpr uint32_t basic_struct_max_cdr_typesize {12UL}; -constexpr uint32_t basic_struct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t TheOtherObject_max_cdr_typesize {8UL}; -constexpr uint32_t TheOtherObject_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const TheOtherObject& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const basic_struct& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp deleted file mode 100644 index baa8d4ad23d..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structCdrAux.ipp +++ /dev/null @@ -1,194 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_structCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP - -#include "basic_structCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const TheOtherObject& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.some_num(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const TheOtherObject& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.some_num() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - TheOtherObject& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.some_num(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const TheOtherObject& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const basic_struct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.sub_struct(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const basic_struct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.sub_struct() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - basic_struct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.sub_struct(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const basic_struct& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__BASIC_STRUCTCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx deleted file mode 100644 index b57ea0db1c6..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.cxx +++ /dev/null @@ -1,157 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file basic_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "basic_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "basic_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_TheOtherObject_type_identifier( - TypeIdentifierPair& type_ids_TheOtherObject) -{ - - ReturnCode_t return_code_TheOtherObject {eprosima::fastdds::dds::RETCODE_OK}; - return_code_TheOtherObject = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "TheOtherObject", type_ids_TheOtherObject); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_TheOtherObject) - { - StructTypeFlag struct_flags_TheOtherObject = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_TheOtherObject = "TheOtherObject"; - eprosima::fastcdr::optional type_ann_builtin_TheOtherObject; - eprosima::fastcdr::optional ann_custom_TheOtherObject; - CompleteTypeDetail detail_TheOtherObject = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_TheOtherObject, ann_custom_TheOtherObject, type_name_TheOtherObject.to_string()); - CompleteStructHeader header_TheOtherObject; - header_TheOtherObject = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_TheOtherObject); - CompleteStructMemberSeq member_seq_TheOtherObject; - { - TypeIdentifierPair type_ids_some_num; - ReturnCode_t return_code_some_num {eprosima::fastdds::dds::RETCODE_OK}; - return_code_some_num = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_some_num); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_some_num) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "some_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_some_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_some_num = 0x00000000; - bool common_some_num_ec {false}; - CommonStructMember common_some_num {TypeObjectUtils::build_common_struct_member(member_id_some_num, member_flags_some_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_some_num, common_some_num_ec))}; - if (!common_some_num_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure some_num member TypeIdentifier inconsistent."); - return; - } - MemberName name_some_num = "some_num"; - eprosima::fastcdr::optional member_ann_builtin_some_num; - ann_custom_TheOtherObject.reset(); - CompleteMemberDetail detail_some_num = TypeObjectUtils::build_complete_member_detail(name_some_num, member_ann_builtin_some_num, ann_custom_TheOtherObject); - CompleteStructMember member_some_num = TypeObjectUtils::build_complete_struct_member(common_some_num, detail_some_num); - TypeObjectUtils::add_complete_struct_member(member_seq_TheOtherObject, member_some_num); - } - CompleteStructType struct_type_TheOtherObject = TypeObjectUtils::build_complete_struct_type(struct_flags_TheOtherObject, header_TheOtherObject, member_seq_TheOtherObject); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_TheOtherObject, type_name_TheOtherObject.to_string(), type_ids_TheOtherObject)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "TheOtherObject already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_basic_struct_type_identifier( - TypeIdentifierPair& type_ids_basic_struct) -{ - - ReturnCode_t return_code_basic_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_basic_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "basic_struct", type_ids_basic_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_basic_struct) - { - StructTypeFlag struct_flags_basic_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_basic_struct = "basic_struct"; - eprosima::fastcdr::optional type_ann_builtin_basic_struct; - eprosima::fastcdr::optional ann_custom_basic_struct; - CompleteTypeDetail detail_basic_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_basic_struct, ann_custom_basic_struct, type_name_basic_struct.to_string()); - CompleteStructHeader header_basic_struct; - header_basic_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_basic_struct); - CompleteStructMemberSeq member_seq_basic_struct; - { - TypeIdentifierPair type_ids_sub_struct; - ReturnCode_t return_code_sub_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_sub_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "TheOtherObject", type_ids_sub_struct); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub_struct) - { - ::register_TheOtherObject_type_identifier(type_ids_sub_struct); - } - StructMemberFlag member_flags_sub_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_sub_struct = 0x00000000; - bool common_sub_struct_ec {false}; - CommonStructMember common_sub_struct {TypeObjectUtils::build_common_struct_member(member_id_sub_struct, member_flags_sub_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub_struct, common_sub_struct_ec))}; - if (!common_sub_struct_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub_struct member TypeIdentifier inconsistent."); - return; - } - MemberName name_sub_struct = "sub_struct"; - eprosima::fastcdr::optional member_ann_builtin_sub_struct; - ann_custom_basic_struct.reset(); - CompleteMemberDetail detail_sub_struct = TypeObjectUtils::build_complete_member_detail(name_sub_struct, member_ann_builtin_sub_struct, ann_custom_basic_struct); - CompleteStructMember member_sub_struct = TypeObjectUtils::build_complete_struct_member(common_sub_struct, detail_sub_struct); - TypeObjectUtils::add_complete_struct_member(member_seq_basic_struct, member_sub_struct); - } - CompleteStructType struct_type_basic_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_basic_struct, header_basic_struct, member_seq_basic_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_basic_struct, type_name_basic_struct.to_string(), type_ids_basic_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "basic_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp deleted file mode 100644 index 98e9d53386a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequence.hpp +++ /dev/null @@ -1,190 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequence.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_HPP -#define FAST_DDS_GENERATED__CHAR_SEQUENCE_HPP - -#include -#include -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(CHAR_SEQUENCE_SOURCE) -#define CHAR_SEQUENCE_DllAPI __declspec( dllexport ) -#else -#define CHAR_SEQUENCE_DllAPI __declspec( dllimport ) -#endif // CHAR_SEQUENCE_SOURCE -#else -#define CHAR_SEQUENCE_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define CHAR_SEQUENCE_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure char_sequence defined by the user in the IDL file. - * @ingroup char_sequence - */ -class char_sequence -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport char_sequence() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~char_sequence() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object char_sequence that will be copied. - */ - eProsima_user_DllExport char_sequence( - const char_sequence& x) - { - m_chars = x.m_chars; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object char_sequence that will be copied. - */ - eProsima_user_DllExport char_sequence( - char_sequence&& x) noexcept - { - m_chars = std::move(x.m_chars); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object char_sequence that will be copied. - */ - eProsima_user_DllExport char_sequence& operator =( - const char_sequence& x) - { - - m_chars = x.m_chars; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object char_sequence that will be copied. - */ - eProsima_user_DllExport char_sequence& operator =( - char_sequence&& x) noexcept - { - - m_chars = std::move(x.m_chars); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x char_sequence object to compare. - */ - eProsima_user_DllExport bool operator ==( - const char_sequence& x) const - { - return (m_chars == x.m_chars); - } - - /*! - * @brief Comparison operator. - * @param x char_sequence object to compare. - */ - eProsima_user_DllExport bool operator !=( - const char_sequence& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member chars - * @param _chars New value to be copied in member chars - */ - eProsima_user_DllExport void chars( - const std::vector& _chars) - { - m_chars = _chars; - } - - /*! - * @brief This function moves the value in member chars - * @param _chars New value to be moved in member chars - */ - eProsima_user_DllExport void chars( - std::vector&& _chars) - { - m_chars = std::move(_chars); - } - - /*! - * @brief This function returns a constant reference to member chars - * @return Constant reference to member chars - */ - eProsima_user_DllExport const std::vector& chars() const - { - return m_chars; - } - - /*! - * @brief This function returns a reference to member chars - * @return Reference to member chars - */ - eProsima_user_DllExport std::vector& chars() - { - return m_chars; - } - - - -private: - - std::vector m_chars; - -}; - -#endif // _FAST_DDS_GENERATED_CHAR_SEQUENCE_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp deleted file mode 100644 index a1d9b9ad755..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequenceCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP -#define FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP - -#include "char_sequence.hpp" - -constexpr uint32_t char_sequence_max_cdr_typesize {8UL}; -constexpr uint32_t char_sequence_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const char_sequence& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp deleted file mode 100644 index ef63929e280..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceCdrAux.ipp +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequenceCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP -#define FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP - -#include "char_sequenceCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const char_sequence& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.chars(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const char_sequence& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.chars() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - char_sequence& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.chars(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const char_sequence& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__CHAR_SEQUENCECDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx deleted file mode 100644 index c066f9e0b1d..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequencePubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "char_sequencePubSubTypes.hpp" - -#include -#include - -#include "char_sequenceCdrAux.hpp" -#include "char_sequenceTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -char_sequencePubSubType::char_sequencePubSubType() -{ - setName("char_sequence"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(char_sequence::getMaxCdrSerializedSize()); -#else - char_sequence_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = char_sequence_max_key_cdr_typesize > 16 ? char_sequence_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -char_sequencePubSubType::~char_sequencePubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool char_sequencePubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const char_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool char_sequencePubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - char_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function char_sequencePubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* char_sequencePubSubType::createData() -{ - return reinterpret_cast(new char_sequence()); -} - -void char_sequencePubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool char_sequencePubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const char_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - char_sequence_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || char_sequence_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void char_sequencePubSubType::register_type_object_representation() -{ - register_char_sequence_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "char_sequenceCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp deleted file mode 100644 index 90af7267056..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequencePubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequencePubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "char_sequence.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated char_sequence is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type char_sequence defined by the user in the IDL file. - * @ingroup char_sequence - */ -class char_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef char_sequence type; - - eProsima_user_DllExport char_sequencePubSubType(); - - eProsima_user_DllExport ~char_sequencePubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__CHAR_SEQUENCE_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx deleted file mode 100644 index 24ddf288868..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.cxx +++ /dev/null @@ -1,132 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequenceTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "char_sequenceTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "char_sequence.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_char_sequence_type_identifier( - TypeIdentifierPair& type_ids_char_sequence) -{ - - ReturnCode_t return_code_char_sequence {eprosima::fastdds::dds::RETCODE_OK}; - return_code_char_sequence = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "char_sequence", type_ids_char_sequence); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_char_sequence) - { - StructTypeFlag struct_flags_char_sequence = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_char_sequence = "char_sequence"; - eprosima::fastcdr::optional type_ann_builtin_char_sequence; - eprosima::fastcdr::optional ann_custom_char_sequence; - CompleteTypeDetail detail_char_sequence = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_char_sequence, ann_custom_char_sequence, type_name_char_sequence.to_string()); - CompleteStructHeader header_char_sequence; - header_char_sequence = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_char_sequence); - CompleteStructMemberSeq member_seq_char_sequence; - { - TypeIdentifierPair type_ids_chars; - ReturnCode_t return_code_chars {eprosima::fastdds::dds::RETCODE_OK}; - return_code_chars = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_char_unbounded", type_ids_chars); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_chars) - { - return_code_chars = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_char", type_ids_chars); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_chars) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - bool element_identifier_anonymous_sequence_char_unbounded_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_char_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_chars, element_identifier_anonymous_sequence_char_unbounded_ec))}; - if (!element_identifier_anonymous_sequence_char_unbounded_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_char_unbounded = EK_COMPLETE; - if (TK_NONE == type_ids_chars.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_char_unbounded = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_char_unbounded = 0; - PlainCollectionHeader header_anonymous_sequence_char_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_char_unbounded, element_flags_anonymous_sequence_char_unbounded); - { - SBound bound = 0; - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_char_unbounded, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_char_unbounded)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_char_unbounded", type_ids_chars)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_char_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_chars = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_chars = 0x00000000; - bool common_chars_ec {false}; - CommonStructMember common_chars {TypeObjectUtils::build_common_struct_member(member_id_chars, member_flags_chars, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_chars, common_chars_ec))}; - if (!common_chars_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure chars member TypeIdentifier inconsistent."); - return; - } - MemberName name_chars = "chars"; - eprosima::fastcdr::optional member_ann_builtin_chars; - ann_custom_char_sequence.reset(); - CompleteMemberDetail detail_chars = TypeObjectUtils::build_complete_member_detail(name_chars, member_ann_builtin_chars, ann_custom_char_sequence); - CompleteStructMember member_chars = TypeObjectUtils::build_complete_struct_member(common_chars, detail_chars); - TypeObjectUtils::add_complete_struct_member(member_seq_char_sequence, member_chars); - } - CompleteStructType struct_type_char_sequence = TypeObjectUtils::build_complete_struct_type(struct_flags_char_sequence, header_char_sequence, member_seq_char_sequence); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_char_sequence, type_name_char_sequence.to_string(), type_ids_char_sequence)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "char_sequence already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp deleted file mode 100644 index 45d4779e6b8..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/char_sequence/char_sequenceTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file char_sequenceTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register char_sequence related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_char_sequence_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__CHAR_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp deleted file mode 100644 index 1f7a722b187..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arrays.hpp +++ /dev/null @@ -1,760 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file complex_nested_arrays.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_HPP -#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_HPP - -#include -#include -#include -#include -#include - -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(COMPLEX_NESTED_ARRAYS_SOURCE) -#define COMPLEX_NESTED_ARRAYS_DllAPI __declspec( dllexport ) -#else -#define COMPLEX_NESTED_ARRAYS_DllAPI __declspec( dllimport ) -#endif // COMPLEX_NESTED_ARRAYS_SOURCE -#else -#define COMPLEX_NESTED_ARRAYS_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define COMPLEX_NESTED_ARRAYS_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure ThirdLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays - */ -class ThirdLevelElement -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport ThirdLevelElement() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~ThirdLevelElement() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object ThirdLevelElement that will be copied. - */ - eProsima_user_DllExport ThirdLevelElement( - const ThirdLevelElement& x) - { - m_x = x.m_x; - - m_y = x.m_y; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object ThirdLevelElement that will be copied. - */ - eProsima_user_DllExport ThirdLevelElement( - ThirdLevelElement&& x) noexcept - { - m_x = x.m_x; - m_y = x.m_y; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object ThirdLevelElement that will be copied. - */ - eProsima_user_DllExport ThirdLevelElement& operator =( - const ThirdLevelElement& x) - { - - m_x = x.m_x; - - m_y = x.m_y; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object ThirdLevelElement that will be copied. - */ - eProsima_user_DllExport ThirdLevelElement& operator =( - ThirdLevelElement&& x) noexcept - { - - m_x = x.m_x; - m_y = x.m_y; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x ThirdLevelElement object to compare. - */ - eProsima_user_DllExport bool operator ==( - const ThirdLevelElement& x) const - { - return (m_x == x.m_x && - m_y == x.m_y); - } - - /*! - * @brief Comparison operator. - * @param x ThirdLevelElement object to compare. - */ - eProsima_user_DllExport bool operator !=( - const ThirdLevelElement& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member x - * @param _x New value for member x - */ - eProsima_user_DllExport void x( - double _x) - { - m_x = _x; - } - - /*! - * @brief This function returns the value of member x - * @return Value of member x - */ - eProsima_user_DllExport double x() const - { - return m_x; - } - - /*! - * @brief This function returns a reference to member x - * @return Reference to member x - */ - eProsima_user_DllExport double& x() - { - return m_x; - } - - - /*! - * @brief This function sets a value in member y - * @param _y New value for member y - */ - eProsima_user_DllExport void y( - double _y) - { - m_y = _y; - } - - /*! - * @brief This function returns the value of member y - * @return Value of member y - */ - eProsima_user_DllExport double y() const - { - return m_y; - } - - /*! - * @brief This function returns a reference to member y - * @return Reference to member y - */ - eProsima_user_DllExport double& y() - { - return m_y; - } - - - -private: - - double m_x{0.0}; - double m_y{0.0}; - -}; -/*! - * @brief This class represents the structure SecondLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays - */ -class SecondLevelElement -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport SecondLevelElement() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~SecondLevelElement() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object SecondLevelElement that will be copied. - */ - eProsima_user_DllExport SecondLevelElement( - const SecondLevelElement& x) - { - m_an_element_alone = x.m_an_element_alone; - - m_a_limited_other_value = x.m_a_limited_other_value; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object SecondLevelElement that will be copied. - */ - eProsima_user_DllExport SecondLevelElement( - SecondLevelElement&& x) noexcept - { - m_an_element_alone = std::move(x.m_an_element_alone); - m_a_limited_other_value = std::move(x.m_a_limited_other_value); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object SecondLevelElement that will be copied. - */ - eProsima_user_DllExport SecondLevelElement& operator =( - const SecondLevelElement& x) - { - - m_an_element_alone = x.m_an_element_alone; - - m_a_limited_other_value = x.m_a_limited_other_value; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object SecondLevelElement that will be copied. - */ - eProsima_user_DllExport SecondLevelElement& operator =( - SecondLevelElement&& x) noexcept - { - - m_an_element_alone = std::move(x.m_an_element_alone); - m_a_limited_other_value = std::move(x.m_a_limited_other_value); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x SecondLevelElement object to compare. - */ - eProsima_user_DllExport bool operator ==( - const SecondLevelElement& x) const - { - return (m_an_element_alone == x.m_an_element_alone && - m_a_limited_other_value == x.m_a_limited_other_value); - } - - /*! - * @brief Comparison operator. - * @param x SecondLevelElement object to compare. - */ - eProsima_user_DllExport bool operator !=( - const SecondLevelElement& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member an_element_alone - * @param _an_element_alone New value to be copied in member an_element_alone - */ - eProsima_user_DllExport void an_element_alone( - const ThirdLevelElement& _an_element_alone) - { - m_an_element_alone = _an_element_alone; - } - - /*! - * @brief This function moves the value in member an_element_alone - * @param _an_element_alone New value to be moved in member an_element_alone - */ - eProsima_user_DllExport void an_element_alone( - ThirdLevelElement&& _an_element_alone) - { - m_an_element_alone = std::move(_an_element_alone); - } - - /*! - * @brief This function returns a constant reference to member an_element_alone - * @return Constant reference to member an_element_alone - */ - eProsima_user_DllExport const ThirdLevelElement& an_element_alone() const - { - return m_an_element_alone; - } - - /*! - * @brief This function returns a reference to member an_element_alone - * @return Reference to member an_element_alone - */ - eProsima_user_DllExport ThirdLevelElement& an_element_alone() - { - return m_an_element_alone; - } - - - /*! - * @brief This function copies the value in member a_limited_other_value - * @param _a_limited_other_value New value to be copied in member a_limited_other_value - */ - eProsima_user_DllExport void a_limited_other_value( - const std::vector& _a_limited_other_value) - { - m_a_limited_other_value = _a_limited_other_value; - } - - /*! - * @brief This function moves the value in member a_limited_other_value - * @param _a_limited_other_value New value to be moved in member a_limited_other_value - */ - eProsima_user_DllExport void a_limited_other_value( - std::vector&& _a_limited_other_value) - { - m_a_limited_other_value = std::move(_a_limited_other_value); - } - - /*! - * @brief This function returns a constant reference to member a_limited_other_value - * @return Constant reference to member a_limited_other_value - */ - eProsima_user_DllExport const std::vector& a_limited_other_value() const - { - return m_a_limited_other_value; - } - - /*! - * @brief This function returns a reference to member a_limited_other_value - * @return Reference to member a_limited_other_value - */ - eProsima_user_DllExport std::vector& a_limited_other_value() - { - return m_a_limited_other_value; - } - - - -private: - - ThirdLevelElement m_an_element_alone; - std::vector m_a_limited_other_value; - -}; -/*! - * @brief This class represents the structure FirstLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays - */ -class FirstLevelElement -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport FirstLevelElement() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~FirstLevelElement() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object FirstLevelElement that will be copied. - */ - eProsima_user_DllExport FirstLevelElement( - const FirstLevelElement& x) - { - m_useless_name = x.m_useless_name; - - m_sub = x.m_sub; - - m_an_element_alone = x.m_an_element_alone; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object FirstLevelElement that will be copied. - */ - eProsima_user_DllExport FirstLevelElement( - FirstLevelElement&& x) noexcept - { - m_useless_name = std::move(x.m_useless_name); - m_sub = std::move(x.m_sub); - m_an_element_alone = std::move(x.m_an_element_alone); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object FirstLevelElement that will be copied. - */ - eProsima_user_DllExport FirstLevelElement& operator =( - const FirstLevelElement& x) - { - - m_useless_name = x.m_useless_name; - - m_sub = x.m_sub; - - m_an_element_alone = x.m_an_element_alone; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object FirstLevelElement that will be copied. - */ - eProsima_user_DllExport FirstLevelElement& operator =( - FirstLevelElement&& x) noexcept - { - - m_useless_name = std::move(x.m_useless_name); - m_sub = std::move(x.m_sub); - m_an_element_alone = std::move(x.m_an_element_alone); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x FirstLevelElement object to compare. - */ - eProsima_user_DllExport bool operator ==( - const FirstLevelElement& x) const - { - return (m_useless_name == x.m_useless_name && - m_sub == x.m_sub && - m_an_element_alone == x.m_an_element_alone); - } - - /*! - * @brief Comparison operator. - * @param x FirstLevelElement object to compare. - */ - eProsima_user_DllExport bool operator !=( - const FirstLevelElement& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member useless_name - * @param _useless_name New value to be copied in member useless_name - */ - eProsima_user_DllExport void useless_name( - const std::string& _useless_name) - { - m_useless_name = _useless_name; - } - - /*! - * @brief This function moves the value in member useless_name - * @param _useless_name New value to be moved in member useless_name - */ - eProsima_user_DllExport void useless_name( - std::string&& _useless_name) - { - m_useless_name = std::move(_useless_name); - } - - /*! - * @brief This function returns a constant reference to member useless_name - * @return Constant reference to member useless_name - */ - eProsima_user_DllExport const std::string& useless_name() const - { - return m_useless_name; - } - - /*! - * @brief This function returns a reference to member useless_name - * @return Reference to member useless_name - */ - eProsima_user_DllExport std::string& useless_name() - { - return m_useless_name; - } - - - /*! - * @brief This function copies the value in member sub - * @param _sub New value to be copied in member sub - */ - eProsima_user_DllExport void sub( - const std::vector& _sub) - { - m_sub = _sub; - } - - /*! - * @brief This function moves the value in member sub - * @param _sub New value to be moved in member sub - */ - eProsima_user_DllExport void sub( - std::vector&& _sub) - { - m_sub = std::move(_sub); - } - - /*! - * @brief This function returns a constant reference to member sub - * @return Constant reference to member sub - */ - eProsima_user_DllExport const std::vector& sub() const - { - return m_sub; - } - - /*! - * @brief This function returns a reference to member sub - * @return Reference to member sub - */ - eProsima_user_DllExport std::vector& sub() - { - return m_sub; - } - - - /*! - * @brief This function copies the value in member an_element_alone - * @param _an_element_alone New value to be copied in member an_element_alone - */ - eProsima_user_DllExport void an_element_alone( - const ThirdLevelElement& _an_element_alone) - { - m_an_element_alone = _an_element_alone; - } - - /*! - * @brief This function moves the value in member an_element_alone - * @param _an_element_alone New value to be moved in member an_element_alone - */ - eProsima_user_DllExport void an_element_alone( - ThirdLevelElement&& _an_element_alone) - { - m_an_element_alone = std::move(_an_element_alone); - } - - /*! - * @brief This function returns a constant reference to member an_element_alone - * @return Constant reference to member an_element_alone - */ - eProsima_user_DllExport const ThirdLevelElement& an_element_alone() const - { - return m_an_element_alone; - } - - /*! - * @brief This function returns a reference to member an_element_alone - * @return Reference to member an_element_alone - */ - eProsima_user_DllExport ThirdLevelElement& an_element_alone() - { - return m_an_element_alone; - } - - - -private: - - std::string m_useless_name; - std::vector m_sub; - ThirdLevelElement m_an_element_alone; - -}; -/*! - * @brief This class represents the structure complex_nested_arrays defined by the user in the IDL file. - * @ingroup complex_nested_arrays - */ -class complex_nested_arrays -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport complex_nested_arrays() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~complex_nested_arrays() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object complex_nested_arrays that will be copied. - */ - eProsima_user_DllExport complex_nested_arrays( - const complex_nested_arrays& x) - { - m_array_of_elements = x.m_array_of_elements; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object complex_nested_arrays that will be copied. - */ - eProsima_user_DllExport complex_nested_arrays( - complex_nested_arrays&& x) noexcept - { - m_array_of_elements = std::move(x.m_array_of_elements); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object complex_nested_arrays that will be copied. - */ - eProsima_user_DllExport complex_nested_arrays& operator =( - const complex_nested_arrays& x) - { - - m_array_of_elements = x.m_array_of_elements; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object complex_nested_arrays that will be copied. - */ - eProsima_user_DllExport complex_nested_arrays& operator =( - complex_nested_arrays&& x) noexcept - { - - m_array_of_elements = std::move(x.m_array_of_elements); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x complex_nested_arrays object to compare. - */ - eProsima_user_DllExport bool operator ==( - const complex_nested_arrays& x) const - { - return (m_array_of_elements == x.m_array_of_elements); - } - - /*! - * @brief Comparison operator. - * @param x complex_nested_arrays object to compare. - */ - eProsima_user_DllExport bool operator !=( - const complex_nested_arrays& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member array_of_elements - * @param _array_of_elements New value to be copied in member array_of_elements - */ - eProsima_user_DllExport void array_of_elements( - const std::array& _array_of_elements) - { - m_array_of_elements = _array_of_elements; - } - - /*! - * @brief This function moves the value in member array_of_elements - * @param _array_of_elements New value to be moved in member array_of_elements - */ - eProsima_user_DllExport void array_of_elements( - std::array&& _array_of_elements) - { - m_array_of_elements = std::move(_array_of_elements); - } - - /*! - * @brief This function returns a constant reference to member array_of_elements - * @return Constant reference to member array_of_elements - */ - eProsima_user_DllExport const std::array& array_of_elements() const - { - return m_array_of_elements; - } - - /*! - * @brief This function returns a reference to member array_of_elements - * @return Reference to member array_of_elements - */ - eProsima_user_DllExport std::array& array_of_elements() - { - return m_array_of_elements; - } - - - -private: - - std::array m_array_of_elements; - -}; - -#endif // _FAST_DDS_GENERATED_COMPLEX_NESTED_ARRAYS_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx deleted file mode 100644 index 2e9d0cf46b5..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.cxx +++ /dev/null @@ -1,493 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file complex_nested_arraysTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "complex_nested_arraysTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "complex_nested_arrays.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_ThirdLevelElement_type_identifier( - TypeIdentifierPair& type_ids_ThirdLevelElement) -{ - - ReturnCode_t return_code_ThirdLevelElement {eprosima::fastdds::dds::RETCODE_OK}; - return_code_ThirdLevelElement = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdLevelElement", type_ids_ThirdLevelElement); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_ThirdLevelElement) - { - StructTypeFlag struct_flags_ThirdLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_ThirdLevelElement = "ThirdLevelElement"; - eprosima::fastcdr::optional type_ann_builtin_ThirdLevelElement; - eprosima::fastcdr::optional ann_custom_ThirdLevelElement; - CompleteTypeDetail detail_ThirdLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ThirdLevelElement, ann_custom_ThirdLevelElement, type_name_ThirdLevelElement.to_string()); - CompleteStructHeader header_ThirdLevelElement; - header_ThirdLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ThirdLevelElement); - CompleteStructMemberSeq member_seq_ThirdLevelElement; - { - TypeIdentifierPair type_ids_x; - ReturnCode_t return_code_x {eprosima::fastdds::dds::RETCODE_OK}; - return_code_x = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_double", type_ids_x); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_x) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "x Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_x = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_x = 0x00000000; - bool common_x_ec {false}; - CommonStructMember common_x {TypeObjectUtils::build_common_struct_member(member_id_x, member_flags_x, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_x, common_x_ec))}; - if (!common_x_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure x member TypeIdentifier inconsistent."); - return; - } - MemberName name_x = "x"; - eprosima::fastcdr::optional member_ann_builtin_x; - ann_custom_ThirdLevelElement.reset(); - CompleteMemberDetail detail_x = TypeObjectUtils::build_complete_member_detail(name_x, member_ann_builtin_x, ann_custom_ThirdLevelElement); - CompleteStructMember member_x = TypeObjectUtils::build_complete_struct_member(common_x, detail_x); - TypeObjectUtils::add_complete_struct_member(member_seq_ThirdLevelElement, member_x); - } - { - TypeIdentifierPair type_ids_y; - ReturnCode_t return_code_y {eprosima::fastdds::dds::RETCODE_OK}; - return_code_y = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_double", type_ids_y); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_y) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "y Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_y = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_y = 0x00000001; - bool common_y_ec {false}; - CommonStructMember common_y {TypeObjectUtils::build_common_struct_member(member_id_y, member_flags_y, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_y, common_y_ec))}; - if (!common_y_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure y member TypeIdentifier inconsistent."); - return; - } - MemberName name_y = "y"; - eprosima::fastcdr::optional member_ann_builtin_y; - ann_custom_ThirdLevelElement.reset(); - CompleteMemberDetail detail_y = TypeObjectUtils::build_complete_member_detail(name_y, member_ann_builtin_y, ann_custom_ThirdLevelElement); - CompleteStructMember member_y = TypeObjectUtils::build_complete_struct_member(common_y, detail_y); - TypeObjectUtils::add_complete_struct_member(member_seq_ThirdLevelElement, member_y); - } - CompleteStructType struct_type_ThirdLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_ThirdLevelElement, header_ThirdLevelElement, member_seq_ThirdLevelElement); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_ThirdLevelElement, type_name_ThirdLevelElement.to_string(), type_ids_ThirdLevelElement)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "ThirdLevelElement already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_SecondLevelElement_type_identifier( - TypeIdentifierPair& type_ids_SecondLevelElement) -{ - - ReturnCode_t return_code_SecondLevelElement {eprosima::fastdds::dds::RETCODE_OK}; - return_code_SecondLevelElement = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SecondLevelElement", type_ids_SecondLevelElement); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_SecondLevelElement) - { - StructTypeFlag struct_flags_SecondLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_SecondLevelElement = "SecondLevelElement"; - eprosima::fastcdr::optional type_ann_builtin_SecondLevelElement; - eprosima::fastcdr::optional ann_custom_SecondLevelElement; - CompleteTypeDetail detail_SecondLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SecondLevelElement, ann_custom_SecondLevelElement, type_name_SecondLevelElement.to_string()); - CompleteStructHeader header_SecondLevelElement; - header_SecondLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SecondLevelElement); - CompleteStructMemberSeq member_seq_SecondLevelElement; - { - TypeIdentifierPair type_ids_an_element_alone; - ReturnCode_t return_code_an_element_alone {eprosima::fastdds::dds::RETCODE_OK}; - return_code_an_element_alone = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdLevelElement", type_ids_an_element_alone); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_an_element_alone) - { - ::register_ThirdLevelElement_type_identifier(type_ids_an_element_alone); - } - StructMemberFlag member_flags_an_element_alone = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_an_element_alone = 0x00000000; - bool common_an_element_alone_ec {false}; - CommonStructMember common_an_element_alone {TypeObjectUtils::build_common_struct_member(member_id_an_element_alone, member_flags_an_element_alone, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_an_element_alone, common_an_element_alone_ec))}; - if (!common_an_element_alone_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure an_element_alone member TypeIdentifier inconsistent."); - return; - } - MemberName name_an_element_alone = "an_element_alone"; - eprosima::fastcdr::optional member_ann_builtin_an_element_alone; - ann_custom_SecondLevelElement.reset(); - CompleteMemberDetail detail_an_element_alone = TypeObjectUtils::build_complete_member_detail(name_an_element_alone, member_ann_builtin_an_element_alone, ann_custom_SecondLevelElement); - CompleteStructMember member_an_element_alone = TypeObjectUtils::build_complete_struct_member(common_an_element_alone, detail_an_element_alone); - TypeObjectUtils::add_complete_struct_member(member_seq_SecondLevelElement, member_an_element_alone); - } - { - TypeIdentifierPair type_ids_a_limited_other_value; - ReturnCode_t return_code_a_limited_other_value {eprosima::fastdds::dds::RETCODE_OK}; - return_code_a_limited_other_value = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_ThirdLevelElement_1", type_ids_a_limited_other_value); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_a_limited_other_value) - { - return_code_a_limited_other_value = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdLevelElement", type_ids_a_limited_other_value); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_a_limited_other_value) - { - ::register_ThirdLevelElement_type_identifier(type_ids_a_limited_other_value); - } - bool element_identifier_anonymous_sequence_ThirdLevelElement_1_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_ThirdLevelElement_1 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_a_limited_other_value, element_identifier_anonymous_sequence_ThirdLevelElement_1_ec))}; - if (!element_identifier_anonymous_sequence_ThirdLevelElement_1_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_ThirdLevelElement_1 = EK_COMPLETE; - if (TK_NONE == type_ids_a_limited_other_value.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_ThirdLevelElement_1 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_ThirdLevelElement_1 = 0; - PlainCollectionHeader header_anonymous_sequence_ThirdLevelElement_1 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_ThirdLevelElement_1, element_flags_anonymous_sequence_ThirdLevelElement_1); - { - SBound bound = static_cast(1); - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_ThirdLevelElement_1, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_ThirdLevelElement_1)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_ThirdLevelElement_1", type_ids_a_limited_other_value)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_ThirdLevelElement_1 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_a_limited_other_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_a_limited_other_value = 0x00000001; - bool common_a_limited_other_value_ec {false}; - CommonStructMember common_a_limited_other_value {TypeObjectUtils::build_common_struct_member(member_id_a_limited_other_value, member_flags_a_limited_other_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_a_limited_other_value, common_a_limited_other_value_ec))}; - if (!common_a_limited_other_value_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure a_limited_other_value member TypeIdentifier inconsistent."); - return; - } - MemberName name_a_limited_other_value = "a_limited_other_value"; - eprosima::fastcdr::optional member_ann_builtin_a_limited_other_value; - ann_custom_SecondLevelElement.reset(); - CompleteMemberDetail detail_a_limited_other_value = TypeObjectUtils::build_complete_member_detail(name_a_limited_other_value, member_ann_builtin_a_limited_other_value, ann_custom_SecondLevelElement); - CompleteStructMember member_a_limited_other_value = TypeObjectUtils::build_complete_struct_member(common_a_limited_other_value, detail_a_limited_other_value); - TypeObjectUtils::add_complete_struct_member(member_seq_SecondLevelElement, member_a_limited_other_value); - } - CompleteStructType struct_type_SecondLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_SecondLevelElement, header_SecondLevelElement, member_seq_SecondLevelElement); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_SecondLevelElement, type_name_SecondLevelElement.to_string(), type_ids_SecondLevelElement)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "SecondLevelElement already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_FirstLevelElement_type_identifier( - TypeIdentifierPair& type_ids_FirstLevelElement) -{ - - ReturnCode_t return_code_FirstLevelElement {eprosima::fastdds::dds::RETCODE_OK}; - return_code_FirstLevelElement = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FirstLevelElement", type_ids_FirstLevelElement); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_FirstLevelElement) - { - StructTypeFlag struct_flags_FirstLevelElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_FirstLevelElement = "FirstLevelElement"; - eprosima::fastcdr::optional type_ann_builtin_FirstLevelElement; - eprosima::fastcdr::optional ann_custom_FirstLevelElement; - CompleteTypeDetail detail_FirstLevelElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FirstLevelElement, ann_custom_FirstLevelElement, type_name_FirstLevelElement.to_string()); - CompleteStructHeader header_FirstLevelElement; - header_FirstLevelElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FirstLevelElement); - CompleteStructMemberSeq member_seq_FirstLevelElement; - { - TypeIdentifierPair type_ids_useless_name; - ReturnCode_t return_code_useless_name {eprosima::fastdds::dds::RETCODE_OK}; - return_code_useless_name = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_string_unbounded", type_ids_useless_name); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_useless_name) - { - { - SBound bound = 0; - StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, - "anonymous_string_unbounded", type_ids_useless_name)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_useless_name = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_useless_name = 0x00000000; - bool common_useless_name_ec {false}; - CommonStructMember common_useless_name {TypeObjectUtils::build_common_struct_member(member_id_useless_name, member_flags_useless_name, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_useless_name, common_useless_name_ec))}; - if (!common_useless_name_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure useless_name member TypeIdentifier inconsistent."); - return; - } - MemberName name_useless_name = "useless_name"; - eprosima::fastcdr::optional member_ann_builtin_useless_name; - ann_custom_FirstLevelElement.reset(); - CompleteMemberDetail detail_useless_name = TypeObjectUtils::build_complete_member_detail(name_useless_name, member_ann_builtin_useless_name, ann_custom_FirstLevelElement); - CompleteStructMember member_useless_name = TypeObjectUtils::build_complete_struct_member(common_useless_name, detail_useless_name); - TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_useless_name); - } - { - TypeIdentifierPair type_ids_sub; - ReturnCode_t return_code_sub {eprosima::fastdds::dds::RETCODE_OK}; - return_code_sub = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_SecondLevelElement_unbounded", type_ids_sub); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub) - { - return_code_sub = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SecondLevelElement", type_ids_sub); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_sub) - { - ::register_SecondLevelElement_type_identifier(type_ids_sub); - } - bool element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_SecondLevelElement_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub, element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec))}; - if (!element_identifier_anonymous_sequence_SecondLevelElement_unbounded_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_SecondLevelElement_unbounded = EK_COMPLETE; - if (TK_NONE == type_ids_sub.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_SecondLevelElement_unbounded = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_SecondLevelElement_unbounded = 0; - PlainCollectionHeader header_anonymous_sequence_SecondLevelElement_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_SecondLevelElement_unbounded, element_flags_anonymous_sequence_SecondLevelElement_unbounded); - { - SBound bound = 0; - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_SecondLevelElement_unbounded, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_SecondLevelElement_unbounded)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_SecondLevelElement_unbounded", type_ids_sub)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_SecondLevelElement_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_sub = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_sub = 0x00000001; - bool common_sub_ec {false}; - CommonStructMember common_sub {TypeObjectUtils::build_common_struct_member(member_id_sub, member_flags_sub, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_sub, common_sub_ec))}; - if (!common_sub_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure sub member TypeIdentifier inconsistent."); - return; - } - MemberName name_sub = "sub"; - eprosima::fastcdr::optional member_ann_builtin_sub; - ann_custom_FirstLevelElement.reset(); - CompleteMemberDetail detail_sub = TypeObjectUtils::build_complete_member_detail(name_sub, member_ann_builtin_sub, ann_custom_FirstLevelElement); - CompleteStructMember member_sub = TypeObjectUtils::build_complete_struct_member(common_sub, detail_sub); - TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_sub); - } - { - TypeIdentifierPair type_ids_an_element_alone; - ReturnCode_t return_code_an_element_alone {eprosima::fastdds::dds::RETCODE_OK}; - return_code_an_element_alone = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdLevelElement", type_ids_an_element_alone); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_an_element_alone) - { - ::register_ThirdLevelElement_type_identifier(type_ids_an_element_alone); - } - StructMemberFlag member_flags_an_element_alone = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_an_element_alone = 0x00000002; - bool common_an_element_alone_ec {false}; - CommonStructMember common_an_element_alone {TypeObjectUtils::build_common_struct_member(member_id_an_element_alone, member_flags_an_element_alone, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_an_element_alone, common_an_element_alone_ec))}; - if (!common_an_element_alone_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure an_element_alone member TypeIdentifier inconsistent."); - return; - } - MemberName name_an_element_alone = "an_element_alone"; - eprosima::fastcdr::optional member_ann_builtin_an_element_alone; - ann_custom_FirstLevelElement.reset(); - CompleteMemberDetail detail_an_element_alone = TypeObjectUtils::build_complete_member_detail(name_an_element_alone, member_ann_builtin_an_element_alone, ann_custom_FirstLevelElement); - CompleteStructMember member_an_element_alone = TypeObjectUtils::build_complete_struct_member(common_an_element_alone, detail_an_element_alone); - TypeObjectUtils::add_complete_struct_member(member_seq_FirstLevelElement, member_an_element_alone); - } - CompleteStructType struct_type_FirstLevelElement = TypeObjectUtils::build_complete_struct_type(struct_flags_FirstLevelElement, header_FirstLevelElement, member_seq_FirstLevelElement); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_FirstLevelElement, type_name_FirstLevelElement.to_string(), type_ids_FirstLevelElement)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FirstLevelElement already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_complex_nested_arrays_type_identifier( - TypeIdentifierPair& type_ids_complex_nested_arrays) -{ - - ReturnCode_t return_code_complex_nested_arrays {eprosima::fastdds::dds::RETCODE_OK}; - return_code_complex_nested_arrays = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "complex_nested_arrays", type_ids_complex_nested_arrays); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_complex_nested_arrays) - { - StructTypeFlag struct_flags_complex_nested_arrays = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_complex_nested_arrays = "complex_nested_arrays"; - eprosima::fastcdr::optional type_ann_builtin_complex_nested_arrays; - eprosima::fastcdr::optional ann_custom_complex_nested_arrays; - CompleteTypeDetail detail_complex_nested_arrays = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_complex_nested_arrays, ann_custom_complex_nested_arrays, type_name_complex_nested_arrays.to_string()); - CompleteStructHeader header_complex_nested_arrays; - header_complex_nested_arrays = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_complex_nested_arrays); - CompleteStructMemberSeq member_seq_complex_nested_arrays; - { - TypeIdentifierPair type_ids_array_of_elements; - ReturnCode_t return_code_array_of_elements {eprosima::fastdds::dds::RETCODE_OK}; - return_code_array_of_elements = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_array_FirstLevelElement_3", type_ids_array_of_elements); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_of_elements) - { - return_code_array_of_elements = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FirstLevelElement", type_ids_array_of_elements); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_array_of_elements) - { - ::register_FirstLevelElement_type_identifier(type_ids_array_of_elements); - } - bool element_identifier_anonymous_array_FirstLevelElement_3_ec {false}; - TypeIdentifier* element_identifier_anonymous_array_FirstLevelElement_3 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_of_elements, element_identifier_anonymous_array_FirstLevelElement_3_ec))}; - if (!element_identifier_anonymous_array_FirstLevelElement_3_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_array_FirstLevelElement_3 = EK_COMPLETE; - if (TK_NONE == type_ids_array_of_elements.type_identifier2()._d()) - { - equiv_kind_anonymous_array_FirstLevelElement_3 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_array_FirstLevelElement_3 = 0; - PlainCollectionHeader header_anonymous_array_FirstLevelElement_3 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_FirstLevelElement_3, element_flags_anonymous_array_FirstLevelElement_3); - { - SBoundSeq array_bound_seq; - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(3)); - - PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_FirstLevelElement_3, array_bound_seq, - eprosima::fastcdr::external(element_identifier_anonymous_array_FirstLevelElement_3)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_FirstLevelElement_3", type_ids_array_of_elements)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_array_FirstLevelElement_3 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_array_of_elements = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_array_of_elements = 0x00000000; - bool common_array_of_elements_ec {false}; - CommonStructMember common_array_of_elements {TypeObjectUtils::build_common_struct_member(member_id_array_of_elements, member_flags_array_of_elements, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_array_of_elements, common_array_of_elements_ec))}; - if (!common_array_of_elements_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure array_of_elements member TypeIdentifier inconsistent."); - return; - } - MemberName name_array_of_elements = "array_of_elements"; - eprosima::fastcdr::optional member_ann_builtin_array_of_elements; - ann_custom_complex_nested_arrays.reset(); - CompleteMemberDetail detail_array_of_elements = TypeObjectUtils::build_complete_member_detail(name_array_of_elements, member_ann_builtin_array_of_elements, ann_custom_complex_nested_arrays); - CompleteStructMember member_array_of_elements = TypeObjectUtils::build_complete_struct_member(common_array_of_elements, detail_array_of_elements); - TypeObjectUtils::add_complete_struct_member(member_seq_complex_nested_arrays, member_array_of_elements); - } - CompleteStructType struct_type_complex_nested_arrays = TypeObjectUtils::build_complete_struct_type(struct_flags_complex_nested_arrays, header_complex_nested_arrays, member_seq_complex_nested_arrays); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_complex_nested_arrays, type_name_complex_nested_arrays.to_string(), type_ids_complex_nested_arrays)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "complex_nested_arrays already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp deleted file mode 100644 index 641f52d909c..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequence.hpp +++ /dev/null @@ -1,190 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequence.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_HPP -#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_HPP - -#include -#include -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(FLOAT_BOUNDED_SEQUENCE_SOURCE) -#define FLOAT_BOUNDED_SEQUENCE_DllAPI __declspec( dllexport ) -#else -#define FLOAT_BOUNDED_SEQUENCE_DllAPI __declspec( dllimport ) -#endif // FLOAT_BOUNDED_SEQUENCE_SOURCE -#else -#define FLOAT_BOUNDED_SEQUENCE_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define FLOAT_BOUNDED_SEQUENCE_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure float_bounded_sequence defined by the user in the IDL file. - * @ingroup float_bounded_sequence - */ -class float_bounded_sequence -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport float_bounded_sequence() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~float_bounded_sequence() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object float_bounded_sequence that will be copied. - */ - eProsima_user_DllExport float_bounded_sequence( - const float_bounded_sequence& x) - { - m_numbers = x.m_numbers; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object float_bounded_sequence that will be copied. - */ - eProsima_user_DllExport float_bounded_sequence( - float_bounded_sequence&& x) noexcept - { - m_numbers = std::move(x.m_numbers); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object float_bounded_sequence that will be copied. - */ - eProsima_user_DllExport float_bounded_sequence& operator =( - const float_bounded_sequence& x) - { - - m_numbers = x.m_numbers; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object float_bounded_sequence that will be copied. - */ - eProsima_user_DllExport float_bounded_sequence& operator =( - float_bounded_sequence&& x) noexcept - { - - m_numbers = std::move(x.m_numbers); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x float_bounded_sequence object to compare. - */ - eProsima_user_DllExport bool operator ==( - const float_bounded_sequence& x) const - { - return (m_numbers == x.m_numbers); - } - - /*! - * @brief Comparison operator. - * @param x float_bounded_sequence object to compare. - */ - eProsima_user_DllExport bool operator !=( - const float_bounded_sequence& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member numbers - * @param _numbers New value to be copied in member numbers - */ - eProsima_user_DllExport void numbers( - const std::vector& _numbers) - { - m_numbers = _numbers; - } - - /*! - * @brief This function moves the value in member numbers - * @param _numbers New value to be moved in member numbers - */ - eProsima_user_DllExport void numbers( - std::vector&& _numbers) - { - m_numbers = std::move(_numbers); - } - - /*! - * @brief This function returns a constant reference to member numbers - * @return Constant reference to member numbers - */ - eProsima_user_DllExport const std::vector& numbers() const - { - return m_numbers; - } - - /*! - * @brief This function returns a reference to member numbers - * @return Reference to member numbers - */ - eProsima_user_DllExport std::vector& numbers() - { - return m_numbers; - } - - - -private: - - std::vector m_numbers; - -}; - -#endif // _FAST_DDS_GENERATED_FLOAT_BOUNDED_SEQUENCE_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp deleted file mode 100644 index d41f390ba7a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequenceCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP -#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP - -#include "float_bounded_sequence.hpp" - -constexpr uint32_t float_bounded_sequence_max_cdr_typesize {60UL}; -constexpr uint32_t float_bounded_sequence_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const float_bounded_sequence& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp deleted file mode 100644 index a167cf15144..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceCdrAux.ipp +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequenceCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP -#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP - -#include "float_bounded_sequenceCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const float_bounded_sequence& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.numbers(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const float_bounded_sequence& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.numbers() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - float_bounded_sequence& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.numbers(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const float_bounded_sequence& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCECDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx deleted file mode 100644 index 8c70ebedadf..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequencePubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "float_bounded_sequencePubSubTypes.hpp" - -#include -#include - -#include "float_bounded_sequenceCdrAux.hpp" -#include "float_bounded_sequenceTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -float_bounded_sequencePubSubType::float_bounded_sequencePubSubType() -{ - setName("float_bounded_sequence"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(float_bounded_sequence::getMaxCdrSerializedSize()); -#else - float_bounded_sequence_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = float_bounded_sequence_max_key_cdr_typesize > 16 ? float_bounded_sequence_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -float_bounded_sequencePubSubType::~float_bounded_sequencePubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool float_bounded_sequencePubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const float_bounded_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool float_bounded_sequencePubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - float_bounded_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function float_bounded_sequencePubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* float_bounded_sequencePubSubType::createData() -{ - return reinterpret_cast(new float_bounded_sequence()); -} - -void float_bounded_sequencePubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool float_bounded_sequencePubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const float_bounded_sequence* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - float_bounded_sequence_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || float_bounded_sequence_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void float_bounded_sequencePubSubType::register_type_object_representation() -{ - register_float_bounded_sequence_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "float_bounded_sequenceCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp deleted file mode 100644 index ffc3557f881..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequencePubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequencePubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "float_bounded_sequence.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated float_bounded_sequence is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type float_bounded_sequence defined by the user in the IDL file. - * @ingroup float_bounded_sequence - */ -class float_bounded_sequencePubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef float_bounded_sequence type; - - eProsima_user_DllExport float_bounded_sequencePubSubType(); - - eProsima_user_DllExport ~float_bounded_sequencePubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx deleted file mode 100644 index aa6108f64ac..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.cxx +++ /dev/null @@ -1,132 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequenceTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "float_bounded_sequenceTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "float_bounded_sequence.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_float_bounded_sequence_type_identifier( - TypeIdentifierPair& type_ids_float_bounded_sequence) -{ - - ReturnCode_t return_code_float_bounded_sequence {eprosima::fastdds::dds::RETCODE_OK}; - return_code_float_bounded_sequence = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "float_bounded_sequence", type_ids_float_bounded_sequence); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_float_bounded_sequence) - { - StructTypeFlag struct_flags_float_bounded_sequence = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_float_bounded_sequence = "float_bounded_sequence"; - eprosima::fastcdr::optional type_ann_builtin_float_bounded_sequence; - eprosima::fastcdr::optional ann_custom_float_bounded_sequence; - CompleteTypeDetail detail_float_bounded_sequence = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_float_bounded_sequence, ann_custom_float_bounded_sequence, type_name_float_bounded_sequence.to_string()); - CompleteStructHeader header_float_bounded_sequence; - header_float_bounded_sequence = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_float_bounded_sequence); - CompleteStructMemberSeq member_seq_float_bounded_sequence; - { - TypeIdentifierPair type_ids_numbers; - ReturnCode_t return_code_numbers {eprosima::fastdds::dds::RETCODE_OK}; - return_code_numbers = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_sequence_float_13", type_ids_numbers); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_numbers) - { - return_code_numbers = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_float", type_ids_numbers); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_numbers) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - bool element_identifier_anonymous_sequence_float_13_ec {false}; - TypeIdentifier* element_identifier_anonymous_sequence_float_13 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_numbers, element_identifier_anonymous_sequence_float_13_ec))}; - if (!element_identifier_anonymous_sequence_float_13_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_sequence_float_13 = EK_COMPLETE; - if (TK_NONE == type_ids_numbers.type_identifier2()._d()) - { - equiv_kind_anonymous_sequence_float_13 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_sequence_float_13 = 0; - PlainCollectionHeader header_anonymous_sequence_float_13 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_float_13, element_flags_anonymous_sequence_float_13); - { - SBound bound = static_cast(13); - PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_float_13, bound, - eprosima::fastcdr::external(element_identifier_anonymous_sequence_float_13)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_float_13", type_ids_numbers)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_sequence_float_13 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_numbers = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_numbers = 0x00000000; - bool common_numbers_ec {false}; - CommonStructMember common_numbers {TypeObjectUtils::build_common_struct_member(member_id_numbers, member_flags_numbers, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_numbers, common_numbers_ec))}; - if (!common_numbers_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure numbers member TypeIdentifier inconsistent."); - return; - } - MemberName name_numbers = "numbers"; - eprosima::fastcdr::optional member_ann_builtin_numbers; - ann_custom_float_bounded_sequence.reset(); - CompleteMemberDetail detail_numbers = TypeObjectUtils::build_complete_member_detail(name_numbers, member_ann_builtin_numbers, ann_custom_float_bounded_sequence); - CompleteStructMember member_numbers = TypeObjectUtils::build_complete_struct_member(common_numbers, detail_numbers); - TypeObjectUtils::add_complete_struct_member(member_seq_float_bounded_sequence, member_numbers); - } - CompleteStructType struct_type_float_bounded_sequence = TypeObjectUtils::build_complete_struct_type(struct_flags_float_bounded_sequence, header_float_bounded_sequence, member_seq_float_bounded_sequence); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_float_bounded_sequence, type_name_float_bounded_sequence.to_string(), type_ids_float_bounded_sequence)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "float_bounded_sequence already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp deleted file mode 100644 index 78dab6b6f08..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/float_bounded_sequence/float_bounded_sequenceTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file float_bounded_sequenceTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register float_bounded_sequence related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_float_bounded_sequence_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__FLOAT_BOUNDED_SEQUENCE_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp deleted file mode 100644 index 27ca777dbc3..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_world.hpp +++ /dev/null @@ -1,227 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_world.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__HELLO_WORLD_HPP -#define FAST_DDS_GENERATED__HELLO_WORLD_HPP - -#include -#include -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(HELLO_WORLD_SOURCE) -#define HELLO_WORLD_DllAPI __declspec( dllexport ) -#else -#define HELLO_WORLD_DllAPI __declspec( dllimport ) -#endif // HELLO_WORLD_SOURCE -#else -#define HELLO_WORLD_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define HELLO_WORLD_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure hello_world defined by the user in the IDL file. - * @ingroup hello_world - */ -class hello_world -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport hello_world() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~hello_world() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object hello_world that will be copied. - */ - eProsima_user_DllExport hello_world( - const hello_world& x) - { - m_index = x.m_index; - - m_message = x.m_message; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object hello_world that will be copied. - */ - eProsima_user_DllExport hello_world( - hello_world&& x) noexcept - { - m_index = x.m_index; - m_message = std::move(x.m_message); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object hello_world that will be copied. - */ - eProsima_user_DllExport hello_world& operator =( - const hello_world& x) - { - - m_index = x.m_index; - - m_message = x.m_message; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object hello_world that will be copied. - */ - eProsima_user_DllExport hello_world& operator =( - hello_world&& x) noexcept - { - - m_index = x.m_index; - m_message = std::move(x.m_message); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x hello_world object to compare. - */ - eProsima_user_DllExport bool operator ==( - const hello_world& x) const - { - return (m_index == x.m_index && - m_message == x.m_message); - } - - /*! - * @brief Comparison operator. - * @param x hello_world object to compare. - */ - eProsima_user_DllExport bool operator !=( - const hello_world& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member index - * @param _index New value for member index - */ - eProsima_user_DllExport void index( - uint32_t _index) - { - m_index = _index; - } - - /*! - * @brief This function returns the value of member index - * @return Value of member index - */ - eProsima_user_DllExport uint32_t index() const - { - return m_index; - } - - /*! - * @brief This function returns a reference to member index - * @return Reference to member index - */ - eProsima_user_DllExport uint32_t& index() - { - return m_index; - } - - - /*! - * @brief This function copies the value in member message - * @param _message New value to be copied in member message - */ - eProsima_user_DllExport void message( - const std::string& _message) - { - m_message = _message; - } - - /*! - * @brief This function moves the value in member message - * @param _message New value to be moved in member message - */ - eProsima_user_DllExport void message( - std::string&& _message) - { - m_message = std::move(_message); - } - - /*! - * @brief This function returns a constant reference to member message - * @return Constant reference to member message - */ - eProsima_user_DllExport const std::string& message() const - { - return m_message; - } - - /*! - * @brief This function returns a reference to member message - * @return Reference to member message - */ - eProsima_user_DllExport std::string& message() - { - return m_message; - } - - - -private: - - uint32_t m_index{0}; - std::string m_message; - -}; - -#endif // _FAST_DDS_GENERATED_HELLO_WORLD_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp deleted file mode 100644 index 4837eee8281..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP -#define FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP - -#include "hello_world.hpp" - -constexpr uint32_t hello_world_max_cdr_typesize {268UL}; -constexpr uint32_t hello_world_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const hello_world& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp deleted file mode 100644 index fd4e9f07348..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldCdrAux.ipp +++ /dev/null @@ -1,126 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP -#define FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP - -#include "hello_worldCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const hello_world& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.index(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.message(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const hello_world& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.index() - << eprosima::fastcdr::MemberId(1) << data.message() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - hello_world& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.index(); - break; - - case 1: - dcdr >> data.message(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const hello_world& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__HELLO_WORLDCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx deleted file mode 100644 index f57610d0497..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "hello_worldPubSubTypes.hpp" - -#include -#include - -#include "hello_worldCdrAux.hpp" -#include "hello_worldTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -hello_worldPubSubType::hello_worldPubSubType() -{ - setName("hello_world"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(hello_world::getMaxCdrSerializedSize()); -#else - hello_world_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = hello_world_max_key_cdr_typesize > 16 ? hello_world_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -hello_worldPubSubType::~hello_worldPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool hello_worldPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const hello_world* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool hello_worldPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - hello_world* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function hello_worldPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* hello_worldPubSubType::createData() -{ - return reinterpret_cast(new hello_world()); -} - -void hello_worldPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool hello_worldPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const hello_world* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - hello_world_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || hello_world_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void hello_worldPubSubType::register_type_object_representation() -{ - register_hello_world_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "hello_worldCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp deleted file mode 100644 index 47a4baa30ac..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldPubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "hello_world.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated hello_world is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type hello_world defined by the user in the IDL file. - * @ingroup hello_world - */ -class hello_worldPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef hello_world type; - - eProsima_user_DllExport hello_worldPubSubType(); - - eProsima_user_DllExport ~hello_worldPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__HELLO_WORLD_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx deleted file mode 100644 index 1c19ab8195f..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.cxx +++ /dev/null @@ -1,138 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "hello_worldTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "hello_world.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_hello_world_type_identifier( - TypeIdentifierPair& type_ids_hello_world) -{ - - ReturnCode_t return_code_hello_world {eprosima::fastdds::dds::RETCODE_OK}; - return_code_hello_world = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "hello_world", type_ids_hello_world); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_hello_world) - { - StructTypeFlag struct_flags_hello_world = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_hello_world = "hello_world"; - eprosima::fastcdr::optional type_ann_builtin_hello_world; - eprosima::fastcdr::optional ann_custom_hello_world; - CompleteTypeDetail detail_hello_world = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_hello_world, ann_custom_hello_world, type_name_hello_world.to_string()); - CompleteStructHeader header_hello_world; - header_hello_world = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_hello_world); - CompleteStructMemberSeq member_seq_hello_world; - { - TypeIdentifierPair type_ids_index; - ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK}; - return_code_index = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint32_t", type_ids_index); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_index) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "index Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_index = 0x00000000; - bool common_index_ec {false}; - CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))}; - if (!common_index_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent."); - return; - } - MemberName name_index = "index"; - eprosima::fastcdr::optional member_ann_builtin_index; - ann_custom_hello_world.reset(); - CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_hello_world); - CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index); - TypeObjectUtils::add_complete_struct_member(member_seq_hello_world, member_index); - } - { - TypeIdentifierPair type_ids_message; - ReturnCode_t return_code_message {eprosima::fastdds::dds::RETCODE_OK}; - return_code_message = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_string_unbounded", type_ids_message); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_message) - { - { - SBound bound = 0; - StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, - "anonymous_string_unbounded", type_ids_message)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_message = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_message = 0x00000001; - bool common_message_ec {false}; - CommonStructMember common_message {TypeObjectUtils::build_common_struct_member(member_id_message, member_flags_message, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_message, common_message_ec))}; - if (!common_message_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure message member TypeIdentifier inconsistent."); - return; - } - MemberName name_message = "message"; - eprosima::fastcdr::optional member_ann_builtin_message; - ann_custom_hello_world.reset(); - CompleteMemberDetail detail_message = TypeObjectUtils::build_complete_member_detail(name_message, member_ann_builtin_message, ann_custom_hello_world); - CompleteStructMember member_message = TypeObjectUtils::build_complete_struct_member(common_message, detail_message); - TypeObjectUtils::add_complete_struct_member(member_seq_hello_world, member_message); - } - CompleteStructType struct_type_hello_world = TypeObjectUtils::build_complete_struct_type(struct_flags_hello_world, header_hello_world, member_seq_hello_world); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_hello_world, type_name_hello_world.to_string(), type_ids_hello_world)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "hello_world already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp deleted file mode 100644 index d0a80dd88e3..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/hello_world/hello_worldTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file hello_worldTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register hello_world related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_hello_world_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__HELLO_WORLD_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp deleted file mode 100644 index 7a58ed499c3..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_struct.hpp +++ /dev/null @@ -1,843 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_HPP -#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_HPP - -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(INHERITANCE_STRUCT_SOURCE) -#define INHERITANCE_STRUCT_DllAPI __declspec( dllexport ) -#else -#define INHERITANCE_STRUCT_DllAPI __declspec( dllimport ) -#endif // INHERITANCE_STRUCT_SOURCE -#else -#define INHERITANCE_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define INHERITANCE_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure GreatgrandfatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GreatgrandfatherStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport GreatgrandfatherStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~GreatgrandfatherStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object GreatgrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GreatgrandfatherStruct( - const GreatgrandfatherStruct& x) - { - m_greatgrandfather = x.m_greatgrandfather; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object GreatgrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GreatgrandfatherStruct( - GreatgrandfatherStruct&& x) noexcept - { - m_greatgrandfather = x.m_greatgrandfather; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object GreatgrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GreatgrandfatherStruct& operator =( - const GreatgrandfatherStruct& x) - { - - m_greatgrandfather = x.m_greatgrandfather; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object GreatgrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GreatgrandfatherStruct& operator =( - GreatgrandfatherStruct&& x) noexcept - { - - m_greatgrandfather = x.m_greatgrandfather; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x GreatgrandfatherStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const GreatgrandfatherStruct& x) const - { - return (m_greatgrandfather == x.m_greatgrandfather); - } - - /*! - * @brief Comparison operator. - * @param x GreatgrandfatherStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const GreatgrandfatherStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member greatgrandfather - * @param _greatgrandfather New value for member greatgrandfather - */ - eProsima_user_DllExport void greatgrandfather( - int32_t _greatgrandfather) - { - m_greatgrandfather = _greatgrandfather; - } - - /*! - * @brief This function returns the value of member greatgrandfather - * @return Value of member greatgrandfather - */ - eProsima_user_DllExport int32_t greatgrandfather() const - { - return m_greatgrandfather; - } - - /*! - * @brief This function returns a reference to member greatgrandfather - * @return Reference to member greatgrandfather - */ - eProsima_user_DllExport int32_t& greatgrandfather() - { - return m_greatgrandfather; - } - - - -private: - - int32_t m_greatgrandfather{0}; - -}; -/*! - * @brief This class represents the structure GrandfatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GrandfatherStruct : public GreatgrandfatherStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport GrandfatherStruct() - : GreatgrandfatherStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~GrandfatherStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object GrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GrandfatherStruct( - const GrandfatherStruct& x) - : GreatgrandfatherStruct(x) - { - m_grandfather = x.m_grandfather; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object GrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GrandfatherStruct( - GrandfatherStruct&& x) noexcept - : GreatgrandfatherStruct(std::move(x)) - - { - m_grandfather = x.m_grandfather; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object GrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GrandfatherStruct& operator =( - const GrandfatherStruct& x) - { - GreatgrandfatherStruct::operator =(x); - - m_grandfather = x.m_grandfather; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object GrandfatherStruct that will be copied. - */ - eProsima_user_DllExport GrandfatherStruct& operator =( - GrandfatherStruct&& x) noexcept - { - GreatgrandfatherStruct::operator =(std::move(x)); - - m_grandfather = x.m_grandfather; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x GrandfatherStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const GrandfatherStruct& x) const - { - if (GreatgrandfatherStruct::operator !=(x)) - { - return false; - } - return (m_grandfather == x.m_grandfather); - } - - /*! - * @brief Comparison operator. - * @param x GrandfatherStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const GrandfatherStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member grandfather - * @param _grandfather New value for member grandfather - */ - eProsima_user_DllExport void grandfather( - int32_t _grandfather) - { - m_grandfather = _grandfather; - } - - /*! - * @brief This function returns the value of member grandfather - * @return Value of member grandfather - */ - eProsima_user_DllExport int32_t grandfather() const - { - return m_grandfather; - } - - /*! - * @brief This function returns a reference to member grandfather - * @return Reference to member grandfather - */ - eProsima_user_DllExport int32_t& grandfather() - { - return m_grandfather; - } - - - -private: - - int32_t m_grandfather{0}; - -}; -/*! - * @brief This class represents the structure FatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class FatherStruct : public GrandfatherStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport FatherStruct() - : GrandfatherStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~FatherStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object FatherStruct that will be copied. - */ - eProsima_user_DllExport FatherStruct( - const FatherStruct& x) - : GrandfatherStruct(x) - { - m_father = x.m_father; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object FatherStruct that will be copied. - */ - eProsima_user_DllExport FatherStruct( - FatherStruct&& x) noexcept - : GrandfatherStruct(std::move(x)) - - { - m_father = x.m_father; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object FatherStruct that will be copied. - */ - eProsima_user_DllExport FatherStruct& operator =( - const FatherStruct& x) - { - GrandfatherStruct::operator =(x); - - m_father = x.m_father; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object FatherStruct that will be copied. - */ - eProsima_user_DllExport FatherStruct& operator =( - FatherStruct&& x) noexcept - { - GrandfatherStruct::operator =(std::move(x)); - - m_father = x.m_father; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x FatherStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const FatherStruct& x) const - { - if (GrandfatherStruct::operator !=(x)) - { - return false; - } - return (m_father == x.m_father); - } - - /*! - * @brief Comparison operator. - * @param x FatherStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const FatherStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member father - * @param _father New value for member father - */ - eProsima_user_DllExport void father( - int32_t _father) - { - m_father = _father; - } - - /*! - * @brief This function returns the value of member father - * @return Value of member father - */ - eProsima_user_DllExport int32_t father() const - { - return m_father; - } - - /*! - * @brief This function returns a reference to member father - * @return Reference to member father - */ - eProsima_user_DllExport int32_t& father() - { - return m_father; - } - - - -private: - - int32_t m_father{0}; - -}; -/*! - * @brief This class represents the structure SonStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class SonStruct : public FatherStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport SonStruct() - : FatherStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~SonStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object SonStruct that will be copied. - */ - eProsima_user_DllExport SonStruct( - const SonStruct& x) - : FatherStruct(x) - { - m_son = x.m_son; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object SonStruct that will be copied. - */ - eProsima_user_DllExport SonStruct( - SonStruct&& x) noexcept - : FatherStruct(std::move(x)) - - { - m_son = x.m_son; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object SonStruct that will be copied. - */ - eProsima_user_DllExport SonStruct& operator =( - const SonStruct& x) - { - FatherStruct::operator =(x); - - m_son = x.m_son; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object SonStruct that will be copied. - */ - eProsima_user_DllExport SonStruct& operator =( - SonStruct&& x) noexcept - { - FatherStruct::operator =(std::move(x)); - - m_son = x.m_son; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x SonStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const SonStruct& x) const - { - if (FatherStruct::operator !=(x)) - { - return false; - } - return (m_son == x.m_son); - } - - /*! - * @brief Comparison operator. - * @param x SonStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const SonStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member son - * @param _son New value for member son - */ - eProsima_user_DllExport void son( - int32_t _son) - { - m_son = _son; - } - - /*! - * @brief This function returns the value of member son - * @return Value of member son - */ - eProsima_user_DllExport int32_t son() const - { - return m_son; - } - - /*! - * @brief This function returns a reference to member son - * @return Reference to member son - */ - eProsima_user_DllExport int32_t& son() - { - return m_son; - } - - - -private: - - int32_t m_son{0}; - -}; -/*! - * @brief This class represents the structure GrandsonStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GrandsonStruct : public SonStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport GrandsonStruct() - : SonStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~GrandsonStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object GrandsonStruct that will be copied. - */ - eProsima_user_DllExport GrandsonStruct( - const GrandsonStruct& x) - : SonStruct(x) - { - m_grandson = x.m_grandson; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object GrandsonStruct that will be copied. - */ - eProsima_user_DllExport GrandsonStruct( - GrandsonStruct&& x) noexcept - : SonStruct(std::move(x)) - - { - m_grandson = x.m_grandson; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object GrandsonStruct that will be copied. - */ - eProsima_user_DllExport GrandsonStruct& operator =( - const GrandsonStruct& x) - { - SonStruct::operator =(x); - - m_grandson = x.m_grandson; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object GrandsonStruct that will be copied. - */ - eProsima_user_DllExport GrandsonStruct& operator =( - GrandsonStruct&& x) noexcept - { - SonStruct::operator =(std::move(x)); - - m_grandson = x.m_grandson; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x GrandsonStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const GrandsonStruct& x) const - { - if (SonStruct::operator !=(x)) - { - return false; - } - return (m_grandson == x.m_grandson); - } - - /*! - * @brief Comparison operator. - * @param x GrandsonStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const GrandsonStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member grandson - * @param _grandson New value for member grandson - */ - eProsima_user_DllExport void grandson( - int32_t _grandson) - { - m_grandson = _grandson; - } - - /*! - * @brief This function returns the value of member grandson - * @return Value of member grandson - */ - eProsima_user_DllExport int32_t grandson() const - { - return m_grandson; - } - - /*! - * @brief This function returns a reference to member grandson - * @return Reference to member grandson - */ - eProsima_user_DllExport int32_t& grandson() - { - return m_grandson; - } - - - -private: - - int32_t m_grandson{0}; - -}; -/*! - * @brief This class represents the structure inheritance_struct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class inheritance_struct : public GrandsonStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport inheritance_struct() - : GrandsonStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~inheritance_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object inheritance_struct that will be copied. - */ - eProsima_user_DllExport inheritance_struct( - const inheritance_struct& x) - : GrandsonStruct(x) - { - m_value = x.m_value; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object inheritance_struct that will be copied. - */ - eProsima_user_DllExport inheritance_struct( - inheritance_struct&& x) noexcept - : GrandsonStruct(std::move(x)) - - { - m_value = x.m_value; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object inheritance_struct that will be copied. - */ - eProsima_user_DllExport inheritance_struct& operator =( - const inheritance_struct& x) - { - GrandsonStruct::operator =(x); - - m_value = x.m_value; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object inheritance_struct that will be copied. - */ - eProsima_user_DllExport inheritance_struct& operator =( - inheritance_struct&& x) noexcept - { - GrandsonStruct::operator =(std::move(x)); - - m_value = x.m_value; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x inheritance_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const inheritance_struct& x) const - { - if (GrandsonStruct::operator !=(x)) - { - return false; - } - return (m_value == x.m_value); - } - - /*! - * @brief Comparison operator. - * @param x inheritance_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const inheritance_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member value - * @param _value New value for member value - */ - eProsima_user_DllExport void value( - int32_t _value) - { - m_value = _value; - } - - /*! - * @brief This function returns the value of member value - * @return Value of member value - */ - eProsima_user_DllExport int32_t value() const - { - return m_value; - } - - /*! - * @brief This function returns a reference to member value - * @return Reference to member value - */ - eProsima_user_DllExport int32_t& value() - { - return m_value; - } - - - -private: - - int32_t m_value{0}; - -}; - -#endif // _FAST_DDS_GENERATED_INHERITANCE_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp deleted file mode 100644 index b492934e2c2..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.hpp +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP - -#include "inheritance_struct.hpp" - -constexpr uint32_t GrandsonStruct_max_cdr_typesize {24UL}; -constexpr uint32_t GrandsonStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t GrandfatherStruct_max_cdr_typesize {12UL}; -constexpr uint32_t GrandfatherStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t FatherStruct_max_cdr_typesize {16UL}; -constexpr uint32_t FatherStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t inheritance_struct_max_cdr_typesize {28UL}; -constexpr uint32_t inheritance_struct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t SonStruct_max_cdr_typesize {20UL}; -constexpr uint32_t SonStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t GreatgrandfatherStruct_max_cdr_typesize {8UL}; -constexpr uint32_t GreatgrandfatherStruct_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GreatgrandfatherStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GrandfatherStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FatherStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const SonStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GrandsonStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const inheritance_struct& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp deleted file mode 100644 index 3c4cfbe15f7..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structCdrAux.ipp +++ /dev/null @@ -1,618 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP - -#include "inheritance_structCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const GreatgrandfatherStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const GreatgrandfatherStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - GreatgrandfatherStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GreatgrandfatherStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const GrandfatherStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.grandfather(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const GrandfatherStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() - << eprosima::fastcdr::MemberId(1) << data.grandfather() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - GrandfatherStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - case 1: - dcdr >> data.grandfather(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GrandfatherStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const FatherStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.grandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.father(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const FatherStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() - << eprosima::fastcdr::MemberId(1) << data.grandfather() - << eprosima::fastcdr::MemberId(2) << data.father() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - FatherStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - case 1: - dcdr >> data.grandfather(); - break; - - case 2: - dcdr >> data.father(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FatherStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const SonStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.grandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.father(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.son(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const SonStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() - << eprosima::fastcdr::MemberId(1) << data.grandfather() - << eprosima::fastcdr::MemberId(2) << data.father() - << eprosima::fastcdr::MemberId(3) << data.son() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - SonStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - case 1: - dcdr >> data.grandfather(); - break; - - case 2: - dcdr >> data.father(); - break; - - case 3: - dcdr >> data.son(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const SonStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const GrandsonStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.grandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.father(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.son(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), - data.grandson(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const GrandsonStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() - << eprosima::fastcdr::MemberId(1) << data.grandfather() - << eprosima::fastcdr::MemberId(2) << data.father() - << eprosima::fastcdr::MemberId(3) << data.son() - << eprosima::fastcdr::MemberId(4) << data.grandson() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - GrandsonStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - case 1: - dcdr >> data.grandfather(); - break; - - case 2: - dcdr >> data.father(); - break; - - case 3: - dcdr >> data.son(); - break; - - case 4: - dcdr >> data.grandson(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const GrandsonStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const inheritance_struct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.greatgrandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.grandfather(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.father(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.son(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), - data.grandson(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5), - data.value(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const inheritance_struct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.greatgrandfather() - << eprosima::fastcdr::MemberId(1) << data.grandfather() - << eprosima::fastcdr::MemberId(2) << data.father() - << eprosima::fastcdr::MemberId(3) << data.son() - << eprosima::fastcdr::MemberId(4) << data.grandson() - << eprosima::fastcdr::MemberId(5) << data.value() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - inheritance_struct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.greatgrandfather(); - break; - - case 1: - dcdr >> data.grandfather(); - break; - - case 2: - dcdr >> data.father(); - break; - - case 3: - dcdr >> data.son(); - break; - - case 4: - dcdr >> data.grandson(); - break; - - case 5: - dcdr >> data.value(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const inheritance_struct& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCTCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx deleted file mode 100644 index 900c630868b..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.cxx +++ /dev/null @@ -1,1194 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "inheritance_structPubSubTypes.hpp" - -#include -#include - -#include "inheritance_structCdrAux.hpp" -#include "inheritance_structTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -GreatgrandfatherStructPubSubType::GreatgrandfatherStructPubSubType() -{ - setName("GreatgrandfatherStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(GreatgrandfatherStruct::getMaxCdrSerializedSize()); -#else - GreatgrandfatherStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = GreatgrandfatherStruct_max_key_cdr_typesize > 16 ? GreatgrandfatherStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -GreatgrandfatherStructPubSubType::~GreatgrandfatherStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool GreatgrandfatherStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const GreatgrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool GreatgrandfatherStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - GreatgrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function GreatgrandfatherStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* GreatgrandfatherStructPubSubType::createData() -{ - return reinterpret_cast(new GreatgrandfatherStruct()); -} - -void GreatgrandfatherStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool GreatgrandfatherStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const GreatgrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - GreatgrandfatherStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || GreatgrandfatherStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void GreatgrandfatherStructPubSubType::register_type_object_representation() -{ - register_GreatgrandfatherStruct_type_identifier(type_identifiers_); -} - -GrandfatherStructPubSubType::GrandfatherStructPubSubType() -{ - setName("GrandfatherStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(GrandfatherStruct::getMaxCdrSerializedSize()); -#else - GrandfatherStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = GrandfatherStruct_max_key_cdr_typesize > 16 ? GrandfatherStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -GrandfatherStructPubSubType::~GrandfatherStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool GrandfatherStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const GrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool GrandfatherStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - GrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function GrandfatherStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* GrandfatherStructPubSubType::createData() -{ - return reinterpret_cast(new GrandfatherStruct()); -} - -void GrandfatherStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool GrandfatherStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const GrandfatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - GrandfatherStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || GrandfatherStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void GrandfatherStructPubSubType::register_type_object_representation() -{ - register_GrandfatherStruct_type_identifier(type_identifiers_); -} - -FatherStructPubSubType::FatherStructPubSubType() -{ - setName("FatherStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(FatherStruct::getMaxCdrSerializedSize()); -#else - FatherStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = FatherStruct_max_key_cdr_typesize > 16 ? FatherStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -FatherStructPubSubType::~FatherStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool FatherStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const FatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool FatherStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - FatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function FatherStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* FatherStructPubSubType::createData() -{ - return reinterpret_cast(new FatherStruct()); -} - -void FatherStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool FatherStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const FatherStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - FatherStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || FatherStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void FatherStructPubSubType::register_type_object_representation() -{ - register_FatherStruct_type_identifier(type_identifiers_); -} - -SonStructPubSubType::SonStructPubSubType() -{ - setName("SonStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(SonStruct::getMaxCdrSerializedSize()); -#else - SonStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = SonStruct_max_key_cdr_typesize > 16 ? SonStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -SonStructPubSubType::~SonStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool SonStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const SonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool SonStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - SonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function SonStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* SonStructPubSubType::createData() -{ - return reinterpret_cast(new SonStruct()); -} - -void SonStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool SonStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const SonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - SonStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || SonStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void SonStructPubSubType::register_type_object_representation() -{ - register_SonStruct_type_identifier(type_identifiers_); -} - -GrandsonStructPubSubType::GrandsonStructPubSubType() -{ - setName("GrandsonStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(GrandsonStruct::getMaxCdrSerializedSize()); -#else - GrandsonStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = GrandsonStruct_max_key_cdr_typesize > 16 ? GrandsonStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -GrandsonStructPubSubType::~GrandsonStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool GrandsonStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const GrandsonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool GrandsonStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - GrandsonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function GrandsonStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* GrandsonStructPubSubType::createData() -{ - return reinterpret_cast(new GrandsonStruct()); -} - -void GrandsonStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool GrandsonStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const GrandsonStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - GrandsonStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || GrandsonStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void GrandsonStructPubSubType::register_type_object_representation() -{ - register_GrandsonStruct_type_identifier(type_identifiers_); -} - -inheritance_structPubSubType::inheritance_structPubSubType() -{ - setName("inheritance_struct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(inheritance_struct::getMaxCdrSerializedSize()); -#else - inheritance_struct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = inheritance_struct_max_key_cdr_typesize > 16 ? inheritance_struct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -inheritance_structPubSubType::~inheritance_structPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool inheritance_structPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const inheritance_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool inheritance_structPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - inheritance_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function inheritance_structPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* inheritance_structPubSubType::createData() -{ - return reinterpret_cast(new inheritance_struct()); -} - -void inheritance_structPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool inheritance_structPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const inheritance_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - inheritance_struct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || inheritance_struct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void inheritance_structPubSubType::register_type_object_representation() -{ - register_inheritance_struct_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "inheritance_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp deleted file mode 100644 index aabd0cf204d..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structPubSubTypes.hpp +++ /dev/null @@ -1,588 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "inheritance_struct.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated inheritance_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type GreatgrandfatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GreatgrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef GreatgrandfatherStruct type; - - eProsima_user_DllExport GreatgrandfatherStructPubSubType(); - - eProsima_user_DllExport ~GreatgrandfatherStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type GrandfatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GrandfatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef GrandfatherStruct type; - - eProsima_user_DllExport GrandfatherStructPubSubType(); - - eProsima_user_DllExport ~GrandfatherStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type FatherStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class FatherStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef FatherStruct type; - - eProsima_user_DllExport FatherStructPubSubType(); - - eProsima_user_DllExport ~FatherStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type SonStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class SonStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef SonStruct type; - - eProsima_user_DllExport SonStructPubSubType(); - - eProsima_user_DllExport ~SonStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type GrandsonStruct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class GrandsonStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef GrandsonStruct type; - - eProsima_user_DllExport GrandsonStructPubSubType(); - - eProsima_user_DllExport ~GrandsonStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type inheritance_struct defined by the user in the IDL file. - * @ingroup inheritance_struct - */ -class inheritance_structPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef inheritance_struct type; - - eProsima_user_DllExport inheritance_structPubSubType(); - - eProsima_user_DllExport ~inheritance_structPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCT_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx deleted file mode 100644 index 15d4c81f85a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.cxx +++ /dev/null @@ -1,500 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "inheritance_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "inheritance_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_GreatgrandfatherStruct_type_identifier( - TypeIdentifierPair& type_ids_GreatgrandfatherStruct) -{ - - ReturnCode_t return_code_GreatgrandfatherStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_GreatgrandfatherStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GreatgrandfatherStruct", type_ids_GreatgrandfatherStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_GreatgrandfatherStruct) - { - StructTypeFlag struct_flags_GreatgrandfatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_GreatgrandfatherStruct = "GreatgrandfatherStruct"; - eprosima::fastcdr::optional type_ann_builtin_GreatgrandfatherStruct; - eprosima::fastcdr::optional ann_custom_GreatgrandfatherStruct; - CompleteTypeDetail detail_GreatgrandfatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GreatgrandfatherStruct, ann_custom_GreatgrandfatherStruct, type_name_GreatgrandfatherStruct.to_string()); - CompleteStructHeader header_GreatgrandfatherStruct; - header_GreatgrandfatherStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_GreatgrandfatherStruct); - CompleteStructMemberSeq member_seq_GreatgrandfatherStruct; - { - TypeIdentifierPair type_ids_greatgrandfather; - ReturnCode_t return_code_greatgrandfather {eprosima::fastdds::dds::RETCODE_OK}; - return_code_greatgrandfather = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_greatgrandfather); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_greatgrandfather) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "greatgrandfather Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_greatgrandfather = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_greatgrandfather = 0x00000000; - bool common_greatgrandfather_ec {false}; - CommonStructMember common_greatgrandfather {TypeObjectUtils::build_common_struct_member(member_id_greatgrandfather, member_flags_greatgrandfather, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_greatgrandfather, common_greatgrandfather_ec))}; - if (!common_greatgrandfather_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure greatgrandfather member TypeIdentifier inconsistent."); - return; - } - MemberName name_greatgrandfather = "greatgrandfather"; - eprosima::fastcdr::optional member_ann_builtin_greatgrandfather; - ann_custom_GreatgrandfatherStruct.reset(); - CompleteMemberDetail detail_greatgrandfather = TypeObjectUtils::build_complete_member_detail(name_greatgrandfather, member_ann_builtin_greatgrandfather, ann_custom_GreatgrandfatherStruct); - CompleteStructMember member_greatgrandfather = TypeObjectUtils::build_complete_struct_member(common_greatgrandfather, detail_greatgrandfather); - TypeObjectUtils::add_complete_struct_member(member_seq_GreatgrandfatherStruct, member_greatgrandfather); - } - CompleteStructType struct_type_GreatgrandfatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GreatgrandfatherStruct, header_GreatgrandfatherStruct, member_seq_GreatgrandfatherStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_GreatgrandfatherStruct, type_name_GreatgrandfatherStruct.to_string(), type_ids_GreatgrandfatherStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "GreatgrandfatherStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_GrandfatherStruct_type_identifier( - TypeIdentifierPair& type_ids_GrandfatherStruct) -{ - - ReturnCode_t return_code_GrandfatherStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_GrandfatherStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GrandfatherStruct", type_ids_GrandfatherStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrandfatherStruct) - { - StructTypeFlag struct_flags_GrandfatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - return_code_GrandfatherStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GreatgrandfatherStruct", type_ids_GrandfatherStruct); - - if (return_code_GrandfatherStruct != eprosima::fastdds::dds::RETCODE_OK) - { -::register_GreatgrandfatherStruct_type_identifier(type_ids_GrandfatherStruct); - } - QualifiedTypeName type_name_GrandfatherStruct = "GrandfatherStruct"; - eprosima::fastcdr::optional type_ann_builtin_GrandfatherStruct; - eprosima::fastcdr::optional ann_custom_GrandfatherStruct; - CompleteTypeDetail detail_GrandfatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GrandfatherStruct, ann_custom_GrandfatherStruct, type_name_GrandfatherStruct.to_string()); - CompleteStructHeader header_GrandfatherStruct; - if (EK_COMPLETE == type_ids_GrandfatherStruct.type_identifier1()._d()) - { - header_GrandfatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandfatherStruct.type_identifier1(), detail_GrandfatherStruct); - } - else if (EK_COMPLETE == type_ids_GrandfatherStruct.type_identifier2()._d()) - { - header_GrandfatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandfatherStruct.type_identifier2(), detail_GrandfatherStruct); - } - else - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "GrandfatherStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); - return; - } - CompleteStructMemberSeq member_seq_GrandfatherStruct; - { - TypeIdentifierPair type_ids_grandfather; - ReturnCode_t return_code_grandfather {eprosima::fastdds::dds::RETCODE_OK}; - return_code_grandfather = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_grandfather); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_grandfather) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "grandfather Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_grandfather = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_grandfather = 0x00000001; - bool common_grandfather_ec {false}; - CommonStructMember common_grandfather {TypeObjectUtils::build_common_struct_member(member_id_grandfather, member_flags_grandfather, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_grandfather, common_grandfather_ec))}; - if (!common_grandfather_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure grandfather member TypeIdentifier inconsistent."); - return; - } - MemberName name_grandfather = "grandfather"; - eprosima::fastcdr::optional member_ann_builtin_grandfather; - ann_custom_GrandfatherStruct.reset(); - CompleteMemberDetail detail_grandfather = TypeObjectUtils::build_complete_member_detail(name_grandfather, member_ann_builtin_grandfather, ann_custom_GrandfatherStruct); - CompleteStructMember member_grandfather = TypeObjectUtils::build_complete_struct_member(common_grandfather, detail_grandfather); - TypeObjectUtils::add_complete_struct_member(member_seq_GrandfatherStruct, member_grandfather); - } - CompleteStructType struct_type_GrandfatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GrandfatherStruct, header_GrandfatherStruct, member_seq_GrandfatherStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_GrandfatherStruct, type_name_GrandfatherStruct.to_string(), type_ids_GrandfatherStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "GrandfatherStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_FatherStruct_type_identifier( - TypeIdentifierPair& type_ids_FatherStruct) -{ - - ReturnCode_t return_code_FatherStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_FatherStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FatherStruct", type_ids_FatherStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_FatherStruct) - { - StructTypeFlag struct_flags_FatherStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - return_code_FatherStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GrandfatherStruct", type_ids_FatherStruct); - - if (return_code_FatherStruct != eprosima::fastdds::dds::RETCODE_OK) - { -::register_GrandfatherStruct_type_identifier(type_ids_FatherStruct); - } - QualifiedTypeName type_name_FatherStruct = "FatherStruct"; - eprosima::fastcdr::optional type_ann_builtin_FatherStruct; - eprosima::fastcdr::optional ann_custom_FatherStruct; - CompleteTypeDetail detail_FatherStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FatherStruct, ann_custom_FatherStruct, type_name_FatherStruct.to_string()); - CompleteStructHeader header_FatherStruct; - if (EK_COMPLETE == type_ids_FatherStruct.type_identifier1()._d()) - { - header_FatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_FatherStruct.type_identifier1(), detail_FatherStruct); - } - else if (EK_COMPLETE == type_ids_FatherStruct.type_identifier2()._d()) - { - header_FatherStruct = TypeObjectUtils::build_complete_struct_header(type_ids_FatherStruct.type_identifier2(), detail_FatherStruct); - } - else - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FatherStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); - return; - } - CompleteStructMemberSeq member_seq_FatherStruct; - { - TypeIdentifierPair type_ids_father; - ReturnCode_t return_code_father {eprosima::fastdds::dds::RETCODE_OK}; - return_code_father = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_father); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_father) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "father Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_father = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_father = 0x00000002; - bool common_father_ec {false}; - CommonStructMember common_father {TypeObjectUtils::build_common_struct_member(member_id_father, member_flags_father, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_father, common_father_ec))}; - if (!common_father_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure father member TypeIdentifier inconsistent."); - return; - } - MemberName name_father = "father"; - eprosima::fastcdr::optional member_ann_builtin_father; - ann_custom_FatherStruct.reset(); - CompleteMemberDetail detail_father = TypeObjectUtils::build_complete_member_detail(name_father, member_ann_builtin_father, ann_custom_FatherStruct); - CompleteStructMember member_father = TypeObjectUtils::build_complete_struct_member(common_father, detail_father); - TypeObjectUtils::add_complete_struct_member(member_seq_FatherStruct, member_father); - } - CompleteStructType struct_type_FatherStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FatherStruct, header_FatherStruct, member_seq_FatherStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_FatherStruct, type_name_FatherStruct.to_string(), type_ids_FatherStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FatherStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_SonStruct_type_identifier( - TypeIdentifierPair& type_ids_SonStruct) -{ - - ReturnCode_t return_code_SonStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_SonStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SonStruct", type_ids_SonStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_SonStruct) - { - StructTypeFlag struct_flags_SonStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - return_code_SonStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FatherStruct", type_ids_SonStruct); - - if (return_code_SonStruct != eprosima::fastdds::dds::RETCODE_OK) - { -::register_FatherStruct_type_identifier(type_ids_SonStruct); - } - QualifiedTypeName type_name_SonStruct = "SonStruct"; - eprosima::fastcdr::optional type_ann_builtin_SonStruct; - eprosima::fastcdr::optional ann_custom_SonStruct; - CompleteTypeDetail detail_SonStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SonStruct, ann_custom_SonStruct, type_name_SonStruct.to_string()); - CompleteStructHeader header_SonStruct; - if (EK_COMPLETE == type_ids_SonStruct.type_identifier1()._d()) - { - header_SonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_SonStruct.type_identifier1(), detail_SonStruct); - } - else if (EK_COMPLETE == type_ids_SonStruct.type_identifier2()._d()) - { - header_SonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_SonStruct.type_identifier2(), detail_SonStruct); - } - else - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "SonStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); - return; - } - CompleteStructMemberSeq member_seq_SonStruct; - { - TypeIdentifierPair type_ids_son; - ReturnCode_t return_code_son {eprosima::fastdds::dds::RETCODE_OK}; - return_code_son = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_son); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_son) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "son Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_son = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_son = 0x00000003; - bool common_son_ec {false}; - CommonStructMember common_son {TypeObjectUtils::build_common_struct_member(member_id_son, member_flags_son, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_son, common_son_ec))}; - if (!common_son_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure son member TypeIdentifier inconsistent."); - return; - } - MemberName name_son = "son"; - eprosima::fastcdr::optional member_ann_builtin_son; - ann_custom_SonStruct.reset(); - CompleteMemberDetail detail_son = TypeObjectUtils::build_complete_member_detail(name_son, member_ann_builtin_son, ann_custom_SonStruct); - CompleteStructMember member_son = TypeObjectUtils::build_complete_struct_member(common_son, detail_son); - TypeObjectUtils::add_complete_struct_member(member_seq_SonStruct, member_son); - } - CompleteStructType struct_type_SonStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_SonStruct, header_SonStruct, member_seq_SonStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_SonStruct, type_name_SonStruct.to_string(), type_ids_SonStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "SonStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_GrandsonStruct_type_identifier( - TypeIdentifierPair& type_ids_GrandsonStruct) -{ - - ReturnCode_t return_code_GrandsonStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_GrandsonStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GrandsonStruct", type_ids_GrandsonStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrandsonStruct) - { - StructTypeFlag struct_flags_GrandsonStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - return_code_GrandsonStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SonStruct", type_ids_GrandsonStruct); - - if (return_code_GrandsonStruct != eprosima::fastdds::dds::RETCODE_OK) - { -::register_SonStruct_type_identifier(type_ids_GrandsonStruct); - } - QualifiedTypeName type_name_GrandsonStruct = "GrandsonStruct"; - eprosima::fastcdr::optional type_ann_builtin_GrandsonStruct; - eprosima::fastcdr::optional ann_custom_GrandsonStruct; - CompleteTypeDetail detail_GrandsonStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GrandsonStruct, ann_custom_GrandsonStruct, type_name_GrandsonStruct.to_string()); - CompleteStructHeader header_GrandsonStruct; - if (EK_COMPLETE == type_ids_GrandsonStruct.type_identifier1()._d()) - { - header_GrandsonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandsonStruct.type_identifier1(), detail_GrandsonStruct); - } - else if (EK_COMPLETE == type_ids_GrandsonStruct.type_identifier2()._d()) - { - header_GrandsonStruct = TypeObjectUtils::build_complete_struct_header(type_ids_GrandsonStruct.type_identifier2(), detail_GrandsonStruct); - } - else - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "GrandsonStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); - return; - } - CompleteStructMemberSeq member_seq_GrandsonStruct; - { - TypeIdentifierPair type_ids_grandson; - ReturnCode_t return_code_grandson {eprosima::fastdds::dds::RETCODE_OK}; - return_code_grandson = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_grandson); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_grandson) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "grandson Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_grandson = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_grandson = 0x00000004; - bool common_grandson_ec {false}; - CommonStructMember common_grandson {TypeObjectUtils::build_common_struct_member(member_id_grandson, member_flags_grandson, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_grandson, common_grandson_ec))}; - if (!common_grandson_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure grandson member TypeIdentifier inconsistent."); - return; - } - MemberName name_grandson = "grandson"; - eprosima::fastcdr::optional member_ann_builtin_grandson; - ann_custom_GrandsonStruct.reset(); - CompleteMemberDetail detail_grandson = TypeObjectUtils::build_complete_member_detail(name_grandson, member_ann_builtin_grandson, ann_custom_GrandsonStruct); - CompleteStructMember member_grandson = TypeObjectUtils::build_complete_struct_member(common_grandson, detail_grandson); - TypeObjectUtils::add_complete_struct_member(member_seq_GrandsonStruct, member_grandson); - } - CompleteStructType struct_type_GrandsonStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GrandsonStruct, header_GrandsonStruct, member_seq_GrandsonStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_GrandsonStruct, type_name_GrandsonStruct.to_string(), type_ids_GrandsonStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "GrandsonStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_inheritance_struct_type_identifier( - TypeIdentifierPair& type_ids_inheritance_struct) -{ - - ReturnCode_t return_code_inheritance_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_inheritance_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "inheritance_struct", type_ids_inheritance_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_inheritance_struct) - { - StructTypeFlag struct_flags_inheritance_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - return_code_inheritance_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "GrandsonStruct", type_ids_inheritance_struct); - - if (return_code_inheritance_struct != eprosima::fastdds::dds::RETCODE_OK) - { -::register_GrandsonStruct_type_identifier(type_ids_inheritance_struct); - } - QualifiedTypeName type_name_inheritance_struct = "inheritance_struct"; - eprosima::fastcdr::optional type_ann_builtin_inheritance_struct; - eprosima::fastcdr::optional ann_custom_inheritance_struct; - CompleteTypeDetail detail_inheritance_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_inheritance_struct, ann_custom_inheritance_struct, type_name_inheritance_struct.to_string()); - CompleteStructHeader header_inheritance_struct; - if (EK_COMPLETE == type_ids_inheritance_struct.type_identifier1()._d()) - { - header_inheritance_struct = TypeObjectUtils::build_complete_struct_header(type_ids_inheritance_struct.type_identifier1(), detail_inheritance_struct); - } - else if (EK_COMPLETE == type_ids_inheritance_struct.type_identifier2()._d()) - { - header_inheritance_struct = TypeObjectUtils::build_complete_struct_header(type_ids_inheritance_struct.type_identifier2(), detail_inheritance_struct); - } - else - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "inheritance_struct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); - return; - } - CompleteStructMemberSeq member_seq_inheritance_struct; - { - TypeIdentifierPair type_ids_value; - ReturnCode_t return_code_value {eprosima::fastdds::dds::RETCODE_OK}; - return_code_value = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_value); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_value) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "value Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_value = 0x00000005; - bool common_value_ec {false}; - CommonStructMember common_value {TypeObjectUtils::build_common_struct_member(member_id_value, member_flags_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_value, common_value_ec))}; - if (!common_value_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure value member TypeIdentifier inconsistent."); - return; - } - MemberName name_value = "value"; - eprosima::fastcdr::optional member_ann_builtin_value; - ann_custom_inheritance_struct.reset(); - CompleteMemberDetail detail_value = TypeObjectUtils::build_complete_member_detail(name_value, member_ann_builtin_value, ann_custom_inheritance_struct); - CompleteStructMember member_value = TypeObjectUtils::build_complete_struct_member(common_value, detail_value); - TypeObjectUtils::add_complete_struct_member(member_seq_inheritance_struct, member_value); - } - CompleteStructType struct_type_inheritance_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_inheritance_struct, header_inheritance_struct, member_seq_inheritance_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_inheritance_struct, type_name_inheritance_struct.to_string(), type_ids_inheritance_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "inheritance_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp deleted file mode 100644 index 4bba954636c..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/inheritance_struct/inheritance_structTypeObjectSupport.hpp +++ /dev/null @@ -1,116 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file inheritance_structTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register GreatgrandfatherStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_GreatgrandfatherStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register GrandfatherStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_GrandfatherStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register FatherStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_FatherStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register SonStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_SonStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register GrandsonStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_GrandsonStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register inheritance_struct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_inheritance_struct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__INHERITANCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp deleted file mode 100644 index 620ebce6914..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_struct.hpp +++ /dev/null @@ -1,252 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__KEY_STRUCT_HPP -#define FAST_DDS_GENERATED__KEY_STRUCT_HPP - -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(KEY_STRUCT_SOURCE) -#define KEY_STRUCT_DllAPI __declspec( dllexport ) -#else -#define KEY_STRUCT_DllAPI __declspec( dllimport ) -#endif // KEY_STRUCT_SOURCE -#else -#define KEY_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define KEY_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure key_struct defined by the user in the IDL file. - * @ingroup key_struct - */ -class key_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport key_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~key_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object key_struct that will be copied. - */ - eProsima_user_DllExport key_struct( - const key_struct& x) - { - m_small_num = x.m_small_num; - - m_big_num = x.m_big_num; - - m_huge_num = x.m_huge_num; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object key_struct that will be copied. - */ - eProsima_user_DllExport key_struct( - key_struct&& x) noexcept - { - m_small_num = x.m_small_num; - m_big_num = x.m_big_num; - m_huge_num = x.m_huge_num; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object key_struct that will be copied. - */ - eProsima_user_DllExport key_struct& operator =( - const key_struct& x) - { - - m_small_num = x.m_small_num; - - m_big_num = x.m_big_num; - - m_huge_num = x.m_huge_num; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object key_struct that will be copied. - */ - eProsima_user_DllExport key_struct& operator =( - key_struct&& x) noexcept - { - - m_small_num = x.m_small_num; - m_big_num = x.m_big_num; - m_huge_num = x.m_huge_num; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x key_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const key_struct& x) const - { - return (m_small_num == x.m_small_num && - m_big_num == x.m_big_num && - m_huge_num == x.m_huge_num); - } - - /*! - * @brief Comparison operator. - * @param x key_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const key_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member small_num - * @param _small_num New value for member small_num - */ - eProsima_user_DllExport void small_num( - int16_t _small_num) - { - m_small_num = _small_num; - } - - /*! - * @brief This function returns the value of member small_num - * @return Value of member small_num - */ - eProsima_user_DllExport int16_t small_num() const - { - return m_small_num; - } - - /*! - * @brief This function returns a reference to member small_num - * @return Reference to member small_num - */ - eProsima_user_DllExport int16_t& small_num() - { - return m_small_num; - } - - - /*! - * @brief This function sets a value in member big_num - * @param _big_num New value for member big_num - */ - eProsima_user_DllExport void big_num( - int32_t _big_num) - { - m_big_num = _big_num; - } - - /*! - * @brief This function returns the value of member big_num - * @return Value of member big_num - */ - eProsima_user_DllExport int32_t big_num() const - { - return m_big_num; - } - - /*! - * @brief This function returns a reference to member big_num - * @return Reference to member big_num - */ - eProsima_user_DllExport int32_t& big_num() - { - return m_big_num; - } - - - /*! - * @brief This function sets a value in member huge_num - * @param _huge_num New value for member huge_num - */ - eProsima_user_DllExport void huge_num( - uint64_t _huge_num) - { - m_huge_num = _huge_num; - } - - /*! - * @brief This function returns the value of member huge_num - * @return Value of member huge_num - */ - eProsima_user_DllExport uint64_t huge_num() const - { - return m_huge_num; - } - - /*! - * @brief This function returns a reference to member huge_num - * @return Reference to member huge_num - */ - eProsima_user_DllExport uint64_t& huge_num() - { - return m_huge_num; - } - - - -private: - - int16_t m_small_num{0}; - int32_t m_big_num{0}; - uint64_t m_huge_num{0}; - -}; - -#endif // _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp deleted file mode 100644 index c12fe281c65..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.ipp +++ /dev/null @@ -1,138 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_structCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP - -#include "key_structCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const key_struct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.small_num(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.big_num(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.huge_num(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const key_struct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.small_num() - << eprosima::fastcdr::MemberId(1) << data.big_num() - << eprosima::fastcdr::MemberId(2) << data.huge_num() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - key_struct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.small_num(); - break; - - case 1: - dcdr >> data.big_num(); - break; - - case 2: - dcdr >> data.huge_num(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const key_struct& data) -{ - static_cast(scdr); - static_cast(data); - scdr << data.big_num(); - - scdr << data.huge_num(); - -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx deleted file mode 100644 index f6a91da5a35..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_structPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "key_structPubSubTypes.hpp" - -#include -#include - -#include "key_structCdrAux.hpp" -#include "key_structTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -key_structPubSubType::key_structPubSubType() -{ - setName("key_struct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(key_struct::getMaxCdrSerializedSize()); -#else - key_struct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = true; - uint32_t keyLength = key_struct_max_key_cdr_typesize > 16 ? key_struct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -key_structPubSubType::~key_structPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool key_structPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const key_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool key_structPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - key_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function key_structPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* key_structPubSubType::createData() -{ - return reinterpret_cast(new key_struct()); -} - -void key_structPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool key_structPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const key_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - key_struct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || key_struct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void key_structPubSubType::register_type_object_representation() -{ - register_key_struct_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "key_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp deleted file mode 100644 index fcab3a5870e..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structPubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_structPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "key_struct.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated key_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type key_struct defined by the user in the IDL file. - * @ingroup key_struct - */ -class key_structPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef key_struct type; - - eProsima_user_DllExport key_structPubSubType(); - - eProsima_user_DllExport ~key_structPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx deleted file mode 100644 index b3b72e9fc7f..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.cxx +++ /dev/null @@ -1,186 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "key_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "key_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_key_struct_type_identifier( - TypeIdentifierPair& type_ids_key_struct) -{ - - ReturnCode_t return_code_key_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_key_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "key_struct", type_ids_key_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_key_struct) - { - StructTypeFlag struct_flags_key_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_key_struct = "key_struct"; - eprosima::fastcdr::optional type_ann_builtin_key_struct; - eprosima::fastcdr::optional ann_custom_key_struct; - CompleteTypeDetail detail_key_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_key_struct, ann_custom_key_struct, type_name_key_struct.to_string()); - CompleteStructHeader header_key_struct; - header_key_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_key_struct); - CompleteStructMemberSeq member_seq_key_struct; - { - TypeIdentifierPair type_ids_small_num; - ReturnCode_t return_code_small_num {eprosima::fastdds::dds::RETCODE_OK}; - return_code_small_num = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int16_t", type_ids_small_num); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_small_num) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "small_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_small_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_small_num = 0x00000000; - bool common_small_num_ec {false}; - CommonStructMember common_small_num {TypeObjectUtils::build_common_struct_member(member_id_small_num, member_flags_small_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_small_num, common_small_num_ec))}; - if (!common_small_num_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure small_num member TypeIdentifier inconsistent."); - return; - } - MemberName name_small_num = "small_num"; - eprosima::fastcdr::optional member_ann_builtin_small_num; - ann_custom_key_struct.reset(); - CompleteMemberDetail detail_small_num = TypeObjectUtils::build_complete_member_detail(name_small_num, member_ann_builtin_small_num, ann_custom_key_struct); - CompleteStructMember member_small_num = TypeObjectUtils::build_complete_struct_member(common_small_num, detail_small_num); - TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_small_num); - } - { - TypeIdentifierPair type_ids_big_num; - ReturnCode_t return_code_big_num {eprosima::fastdds::dds::RETCODE_OK}; - return_code_big_num = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_big_num); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_big_num) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "big_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_big_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, true, false); - MemberId member_id_big_num = 0x00000001; - bool common_big_num_ec {false}; - CommonStructMember common_big_num {TypeObjectUtils::build_common_struct_member(member_id_big_num, member_flags_big_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_big_num, common_big_num_ec))}; - if (!common_big_num_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure big_num member TypeIdentifier inconsistent."); - return; - } - MemberName name_big_num = "big_num"; - eprosima::fastcdr::optional member_ann_builtin_big_num; - ann_custom_key_struct.reset(); - AppliedAnnotationSeq tmp_ann_custom_big_num; - eprosima::fastcdr::optional unit_big_num; - eprosima::fastcdr::optional min_big_num; - eprosima::fastcdr::optional max_big_num; - eprosima::fastcdr::optional hash_id_big_num; - if (unit_big_num.has_value() || min_big_num.has_value() || max_big_num.has_value() || hash_id_big_num.has_value()) - { - member_ann_builtin_big_num = TypeObjectUtils::build_applied_builtin_member_annotations(unit_big_num, min_big_num, max_big_num, hash_id_big_num); - } - if (!tmp_ann_custom_big_num.empty()) - { - ann_custom_key_struct = tmp_ann_custom_big_num; - } - CompleteMemberDetail detail_big_num = TypeObjectUtils::build_complete_member_detail(name_big_num, member_ann_builtin_big_num, ann_custom_key_struct); - CompleteStructMember member_big_num = TypeObjectUtils::build_complete_struct_member(common_big_num, detail_big_num); - TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_big_num); - } - { - TypeIdentifierPair type_ids_huge_num; - ReturnCode_t return_code_huge_num {eprosima::fastdds::dds::RETCODE_OK}; - return_code_huge_num = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint64_t", type_ids_huge_num); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_huge_num) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "huge_num Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_huge_num = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, true, false); - MemberId member_id_huge_num = 0x00000002; - bool common_huge_num_ec {false}; - CommonStructMember common_huge_num {TypeObjectUtils::build_common_struct_member(member_id_huge_num, member_flags_huge_num, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_huge_num, common_huge_num_ec))}; - if (!common_huge_num_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure huge_num member TypeIdentifier inconsistent."); - return; - } - MemberName name_huge_num = "huge_num"; - eprosima::fastcdr::optional member_ann_builtin_huge_num; - ann_custom_key_struct.reset(); - AppliedAnnotationSeq tmp_ann_custom_huge_num; - eprosima::fastcdr::optional unit_huge_num; - eprosima::fastcdr::optional min_huge_num; - eprosima::fastcdr::optional max_huge_num; - eprosima::fastcdr::optional hash_id_huge_num; - if (unit_huge_num.has_value() || min_huge_num.has_value() || max_huge_num.has_value() || hash_id_huge_num.has_value()) - { - member_ann_builtin_huge_num = TypeObjectUtils::build_applied_builtin_member_annotations(unit_huge_num, min_huge_num, max_huge_num, hash_id_huge_num); - } - if (!tmp_ann_custom_huge_num.empty()) - { - ann_custom_key_struct = tmp_ann_custom_huge_num; - } - CompleteMemberDetail detail_huge_num = TypeObjectUtils::build_complete_member_detail(name_huge_num, member_ann_builtin_huge_num, ann_custom_key_struct); - CompleteStructMember member_huge_num = TypeObjectUtils::build_complete_struct_member(common_huge_num, detail_huge_num); - TypeObjectUtils::add_complete_struct_member(member_seq_key_struct, member_huge_num); - } - CompleteStructType struct_type_key_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_key_struct, header_key_struct, member_seq_key_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_key_struct, type_name_key_struct.to_string(), type_ids_key_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "key_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp deleted file mode 100644 index 4d141ebf93a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file key_structTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register key_struct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_key_struct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp deleted file mode 100644 index 0cac9acbdc1..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_struct.hpp +++ /dev/null @@ -1,191 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_HPP -#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_HPP - -#include -#include -#include -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(MAP_BOUNDED_STRUCT_SOURCE) -#define MAP_BOUNDED_STRUCT_DllAPI __declspec( dllexport ) -#else -#define MAP_BOUNDED_STRUCT_DllAPI __declspec( dllimport ) -#endif // MAP_BOUNDED_STRUCT_SOURCE -#else -#define MAP_BOUNDED_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define MAP_BOUNDED_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure map_bounded_struct defined by the user in the IDL file. - * @ingroup map_bounded_struct - */ -class map_bounded_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport map_bounded_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~map_bounded_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object map_bounded_struct that will be copied. - */ - eProsima_user_DllExport map_bounded_struct( - const map_bounded_struct& x) - { - m_my_map = x.m_my_map; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object map_bounded_struct that will be copied. - */ - eProsima_user_DllExport map_bounded_struct( - map_bounded_struct&& x) noexcept - { - m_my_map = std::move(x.m_my_map); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object map_bounded_struct that will be copied. - */ - eProsima_user_DllExport map_bounded_struct& operator =( - const map_bounded_struct& x) - { - - m_my_map = x.m_my_map; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object map_bounded_struct that will be copied. - */ - eProsima_user_DllExport map_bounded_struct& operator =( - map_bounded_struct&& x) noexcept - { - - m_my_map = std::move(x.m_my_map); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x map_bounded_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const map_bounded_struct& x) const - { - return (m_my_map == x.m_my_map); - } - - /*! - * @brief Comparison operator. - * @param x map_bounded_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const map_bounded_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member my_map - * @param _my_map New value to be copied in member my_map - */ - eProsima_user_DllExport void my_map( - const std::map& _my_map) - { - m_my_map = _my_map; - } - - /*! - * @brief This function moves the value in member my_map - * @param _my_map New value to be moved in member my_map - */ - eProsima_user_DllExport void my_map( - std::map&& _my_map) - { - m_my_map = std::move(_my_map); - } - - /*! - * @brief This function returns a constant reference to member my_map - * @return Constant reference to member my_map - */ - eProsima_user_DllExport const std::map& my_map() const - { - return m_my_map; - } - - /*! - * @brief This function returns a reference to member my_map - * @return Reference to member my_map - */ - eProsima_user_DllExport std::map& my_map() - { - return m_my_map; - } - - - -private: - - std::map m_my_map; - -}; - -#endif // _FAST_DDS_GENERATED_MAP_BOUNDED_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp deleted file mode 100644 index 44968846043..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP - -#include "map_bounded_struct.hpp" - -constexpr uint32_t map_bounded_struct_max_cdr_typesize {2645UL}; -constexpr uint32_t map_bounded_struct_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const map_bounded_struct& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp deleted file mode 100644 index d397554fb23..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structCdrAux.ipp +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP - -#include "map_bounded_structCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const map_bounded_struct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.my_map(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const map_bounded_struct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.my_map() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - map_bounded_struct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.my_map(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const map_bounded_struct& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCTCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx deleted file mode 100644 index 920d0c0b51e..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "map_bounded_structPubSubTypes.hpp" - -#include -#include - -#include "map_bounded_structCdrAux.hpp" -#include "map_bounded_structTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -map_bounded_structPubSubType::map_bounded_structPubSubType() -{ - setName("map_bounded_struct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(map_bounded_struct::getMaxCdrSerializedSize()); -#else - map_bounded_struct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = map_bounded_struct_max_key_cdr_typesize > 16 ? map_bounded_struct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -map_bounded_structPubSubType::~map_bounded_structPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool map_bounded_structPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const map_bounded_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool map_bounded_structPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - map_bounded_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function map_bounded_structPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* map_bounded_structPubSubType::createData() -{ - return reinterpret_cast(new map_bounded_struct()); -} - -void map_bounded_structPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool map_bounded_structPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const map_bounded_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - map_bounded_struct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || map_bounded_struct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void map_bounded_structPubSubType::register_type_object_representation() -{ - register_map_bounded_struct_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "map_bounded_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp deleted file mode 100644 index fce53a4d2c8..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structPubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "map_bounded_struct.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated map_bounded_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type map_bounded_struct defined by the user in the IDL file. - * @ingroup map_bounded_struct - */ -class map_bounded_structPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef map_bounded_struct type; - - eProsima_user_DllExport map_bounded_structPubSubType(); - - eProsima_user_DllExport ~map_bounded_structPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx deleted file mode 100644 index 32db4e123f1..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.cxx +++ /dev/null @@ -1,167 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "map_bounded_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "map_bounded_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_map_bounded_struct_type_identifier( - TypeIdentifierPair& type_ids_map_bounded_struct) -{ - - ReturnCode_t return_code_map_bounded_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_map_bounded_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "map_bounded_struct", type_ids_map_bounded_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_map_bounded_struct) - { - StructTypeFlag struct_flags_map_bounded_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_map_bounded_struct = "map_bounded_struct"; - eprosima::fastcdr::optional type_ann_builtin_map_bounded_struct; - eprosima::fastcdr::optional ann_custom_map_bounded_struct; - CompleteTypeDetail detail_map_bounded_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_map_bounded_struct, ann_custom_map_bounded_struct, type_name_map_bounded_struct.to_string()); - CompleteStructHeader header_map_bounded_struct; - header_map_bounded_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_map_bounded_struct); - CompleteStructMemberSeq member_seq_map_bounded_struct; - { - TypeIdentifierPair type_ids_my_map; - ReturnCode_t return_code_my_map {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_map = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_map_anonymous_string_unbounded_bool_10", type_ids_my_map); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) - { - return_code_my_map = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_bool", type_ids_my_map); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "Map element TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - bool element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec {false}; - TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_bool_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec))}; - if (!element_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_map_anonymous_string_unbounded_bool_10 inconsistent element TypeIdentifier."); - return; - } - return_code_my_map = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_string_unbounded", type_ids_my_map); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_map) - { - { - SBound bound = 0; - StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, - "anonymous_string_unbounded", type_ids_my_map)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); - } - } - } - bool key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec {false}; - TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_bool_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec))}; - if (!key_identifier_anonymous_map_anonymous_string_unbounded_bool_10_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_map_anonymous_string_unbounded_bool_10 inconsistent key TypeIdentifier."); - return; - } - EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10 = EK_BOTH; - if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d()) || - (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->seq_sdefn().header().equiv_kind()) || - (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->seq_ldefn().header().equiv_kind()) || - (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->array_sdefn().header().equiv_kind()) || - (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->array_ldefn().header().equiv_kind()) || - (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_sdefn().header().equiv_kind())) || - (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_bool_10->map_ldefn().header().equiv_kind()))) - { - equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10 = EK_COMPLETE; - } - CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_bool_10 = 0; - CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_bool_10 = 0; - PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_bool_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_bool_10, element_flags_anonymous_map_anonymous_string_unbounded_bool_10); - { - SBound bound = static_cast(10); - PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_bool_10, bound, - eprosima::fastcdr::external(element_identifier_anonymous_map_anonymous_string_unbounded_bool_10), key_flags_anonymous_map_anonymous_string_unbounded_bool_10, - eprosima::fastcdr::external(key_identifier_anonymous_map_anonymous_string_unbounded_bool_10)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_bool_10", type_ids_my_map)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_map_anonymous_string_unbounded_bool_10 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_my_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_my_map = 0x00000000; - bool common_my_map_ec {false}; - CommonStructMember common_my_map {TypeObjectUtils::build_common_struct_member(member_id_my_map, member_flags_my_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_map, common_my_map_ec))}; - if (!common_my_map_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_map member TypeIdentifier inconsistent."); - return; - } - MemberName name_my_map = "my_map"; - eprosima::fastcdr::optional member_ann_builtin_my_map; - ann_custom_map_bounded_struct.reset(); - CompleteMemberDetail detail_my_map = TypeObjectUtils::build_complete_member_detail(name_my_map, member_ann_builtin_my_map, ann_custom_map_bounded_struct); - CompleteStructMember member_my_map = TypeObjectUtils::build_complete_struct_member(common_my_map, detail_my_map); - TypeObjectUtils::add_complete_struct_member(member_seq_map_bounded_struct, member_my_map); - } - CompleteStructType struct_type_map_bounded_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_map_bounded_struct, header_map_bounded_struct, member_seq_map_bounded_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_map_bounded_struct, type_name_map_bounded_struct.to_string(), type_ids_map_bounded_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "map_bounded_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp deleted file mode 100644 index e3588968c1a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_bounded_struct/map_bounded_structTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file map_bounded_structTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register map_bounded_struct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_map_bounded_struct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__MAP_BOUNDED_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp deleted file mode 100644 index ca019fc28fa..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_struct.hpp +++ /dev/null @@ -1,386 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file multi_array_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_HPP -#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCT_HPP - -#include -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(MULTI_ARRAY_STRUCT_SOURCE) -#define MULTI_ARRAY_STRUCT_DllAPI __declspec( dllexport ) -#else -#define MULTI_ARRAY_STRUCT_DllAPI __declspec( dllimport ) -#endif // MULTI_ARRAY_STRUCT_SOURCE -#else -#define MULTI_ARRAY_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define MULTI_ARRAY_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure ColorAmount defined by the user in the IDL file. - * @ingroup multi_array_struct - */ -class ColorAmount -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport ColorAmount() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~ColorAmount() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object ColorAmount that will be copied. - */ - eProsima_user_DllExport ColorAmount( - const ColorAmount& x) - { - m_red = x.m_red; - - m_green = x.m_green; - - m_blue = x.m_blue; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object ColorAmount that will be copied. - */ - eProsima_user_DllExport ColorAmount( - ColorAmount&& x) noexcept - { - m_red = x.m_red; - m_green = x.m_green; - m_blue = x.m_blue; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object ColorAmount that will be copied. - */ - eProsima_user_DllExport ColorAmount& operator =( - const ColorAmount& x) - { - - m_red = x.m_red; - - m_green = x.m_green; - - m_blue = x.m_blue; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object ColorAmount that will be copied. - */ - eProsima_user_DllExport ColorAmount& operator =( - ColorAmount&& x) noexcept - { - - m_red = x.m_red; - m_green = x.m_green; - m_blue = x.m_blue; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x ColorAmount object to compare. - */ - eProsima_user_DllExport bool operator ==( - const ColorAmount& x) const - { - return (m_red == x.m_red && - m_green == x.m_green && - m_blue == x.m_blue); - } - - /*! - * @brief Comparison operator. - * @param x ColorAmount object to compare. - */ - eProsima_user_DllExport bool operator !=( - const ColorAmount& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member red - * @param _red New value for member red - */ - eProsima_user_DllExport void red( - int32_t _red) - { - m_red = _red; - } - - /*! - * @brief This function returns the value of member red - * @return Value of member red - */ - eProsima_user_DllExport int32_t red() const - { - return m_red; - } - - /*! - * @brief This function returns a reference to member red - * @return Reference to member red - */ - eProsima_user_DllExport int32_t& red() - { - return m_red; - } - - - /*! - * @brief This function sets a value in member green - * @param _green New value for member green - */ - eProsima_user_DllExport void green( - int32_t _green) - { - m_green = _green; - } - - /*! - * @brief This function returns the value of member green - * @return Value of member green - */ - eProsima_user_DllExport int32_t green() const - { - return m_green; - } - - /*! - * @brief This function returns a reference to member green - * @return Reference to member green - */ - eProsima_user_DllExport int32_t& green() - { - return m_green; - } - - - /*! - * @brief This function sets a value in member blue - * @param _blue New value for member blue - */ - eProsima_user_DllExport void blue( - int32_t _blue) - { - m_blue = _blue; - } - - /*! - * @brief This function returns the value of member blue - * @return Value of member blue - */ - eProsima_user_DllExport int32_t blue() const - { - return m_blue; - } - - /*! - * @brief This function returns a reference to member blue - * @return Reference to member blue - */ - eProsima_user_DllExport int32_t& blue() - { - return m_blue; - } - - - -private: - - int32_t m_red{0}; - int32_t m_green{0}; - int32_t m_blue{0}; - -}; -/*! - * @brief This class represents the structure multi_array_struct defined by the user in the IDL file. - * @ingroup multi_array_struct - */ -class multi_array_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport multi_array_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~multi_array_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object multi_array_struct that will be copied. - */ - eProsima_user_DllExport multi_array_struct( - const multi_array_struct& x) - { - m_colors = x.m_colors; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object multi_array_struct that will be copied. - */ - eProsima_user_DllExport multi_array_struct( - multi_array_struct&& x) noexcept - { - m_colors = std::move(x.m_colors); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object multi_array_struct that will be copied. - */ - eProsima_user_DllExport multi_array_struct& operator =( - const multi_array_struct& x) - { - - m_colors = x.m_colors; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object multi_array_struct that will be copied. - */ - eProsima_user_DllExport multi_array_struct& operator =( - multi_array_struct&& x) noexcept - { - - m_colors = std::move(x.m_colors); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x multi_array_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const multi_array_struct& x) const - { - return (m_colors == x.m_colors); - } - - /*! - * @brief Comparison operator. - * @param x multi_array_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const multi_array_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member colors - * @param _colors New value to be copied in member colors - */ - eProsima_user_DllExport void colors( - const std::array, 5>, 5>& _colors) - { - m_colors = _colors; - } - - /*! - * @brief This function moves the value in member colors - * @param _colors New value to be moved in member colors - */ - eProsima_user_DllExport void colors( - std::array, 5>, 5>&& _colors) - { - m_colors = std::move(_colors); - } - - /*! - * @brief This function returns a constant reference to member colors - * @return Constant reference to member colors - */ - eProsima_user_DllExport const std::array, 5>, 5>& colors() const - { - return m_colors; - } - - /*! - * @brief This function returns a reference to member colors - * @return Reference to member colors - */ - eProsima_user_DllExport std::array, 5>, 5>& colors() - { - return m_colors; - } - - - -private: - - std::array, 5>, 5> m_colors; - -}; - -#endif // _FAST_DDS_GENERATED_MULTI_ARRAY_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp deleted file mode 100644 index ed9892d62b3..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file multi_array_structCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP - -#include "multi_array_struct.hpp" - -constexpr uint32_t ColorAmount_max_cdr_typesize {16UL}; -constexpr uint32_t ColorAmount_max_key_cdr_typesize {0UL}; - -constexpr uint32_t multi_array_struct_max_cdr_typesize {2008UL}; -constexpr uint32_t multi_array_struct_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const ColorAmount& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const multi_array_struct& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx deleted file mode 100644 index 0be126797bb..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structTypeObjectSupport.cxx +++ /dev/null @@ -1,255 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file multi_array_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "multi_array_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "multi_array_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_ColorAmount_type_identifier( - TypeIdentifierPair& type_ids_ColorAmount) -{ - - ReturnCode_t return_code_ColorAmount {eprosima::fastdds::dds::RETCODE_OK}; - return_code_ColorAmount = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ColorAmount", type_ids_ColorAmount); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_ColorAmount) - { - StructTypeFlag struct_flags_ColorAmount = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_ColorAmount = "ColorAmount"; - eprosima::fastcdr::optional type_ann_builtin_ColorAmount; - eprosima::fastcdr::optional ann_custom_ColorAmount; - CompleteTypeDetail detail_ColorAmount = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ColorAmount, ann_custom_ColorAmount, type_name_ColorAmount.to_string()); - CompleteStructHeader header_ColorAmount; - header_ColorAmount = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ColorAmount); - CompleteStructMemberSeq member_seq_ColorAmount; - { - TypeIdentifierPair type_ids_red; - ReturnCode_t return_code_red {eprosima::fastdds::dds::RETCODE_OK}; - return_code_red = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_red); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_red) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "red Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_red = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_red = 0x00000000; - bool common_red_ec {false}; - CommonStructMember common_red {TypeObjectUtils::build_common_struct_member(member_id_red, member_flags_red, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_red, common_red_ec))}; - if (!common_red_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure red member TypeIdentifier inconsistent."); - return; - } - MemberName name_red = "red"; - eprosima::fastcdr::optional member_ann_builtin_red; - ann_custom_ColorAmount.reset(); - CompleteMemberDetail detail_red = TypeObjectUtils::build_complete_member_detail(name_red, member_ann_builtin_red, ann_custom_ColorAmount); - CompleteStructMember member_red = TypeObjectUtils::build_complete_struct_member(common_red, detail_red); - TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_red); - } - { - TypeIdentifierPair type_ids_green; - ReturnCode_t return_code_green {eprosima::fastdds::dds::RETCODE_OK}; - return_code_green = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_green); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_green) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "green Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_green = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_green = 0x00000001; - bool common_green_ec {false}; - CommonStructMember common_green {TypeObjectUtils::build_common_struct_member(member_id_green, member_flags_green, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_green, common_green_ec))}; - if (!common_green_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure green member TypeIdentifier inconsistent."); - return; - } - MemberName name_green = "green"; - eprosima::fastcdr::optional member_ann_builtin_green; - ann_custom_ColorAmount.reset(); - CompleteMemberDetail detail_green = TypeObjectUtils::build_complete_member_detail(name_green, member_ann_builtin_green, ann_custom_ColorAmount); - CompleteStructMember member_green = TypeObjectUtils::build_complete_struct_member(common_green, detail_green); - TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_green); - } - { - TypeIdentifierPair type_ids_blue; - ReturnCode_t return_code_blue {eprosima::fastdds::dds::RETCODE_OK}; - return_code_blue = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_blue); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_blue) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "blue Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_blue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_blue = 0x00000002; - bool common_blue_ec {false}; - CommonStructMember common_blue {TypeObjectUtils::build_common_struct_member(member_id_blue, member_flags_blue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_blue, common_blue_ec))}; - if (!common_blue_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure blue member TypeIdentifier inconsistent."); - return; - } - MemberName name_blue = "blue"; - eprosima::fastcdr::optional member_ann_builtin_blue; - ann_custom_ColorAmount.reset(); - CompleteMemberDetail detail_blue = TypeObjectUtils::build_complete_member_detail(name_blue, member_ann_builtin_blue, ann_custom_ColorAmount); - CompleteStructMember member_blue = TypeObjectUtils::build_complete_struct_member(common_blue, detail_blue); - TypeObjectUtils::add_complete_struct_member(member_seq_ColorAmount, member_blue); - } - CompleteStructType struct_type_ColorAmount = TypeObjectUtils::build_complete_struct_type(struct_flags_ColorAmount, header_ColorAmount, member_seq_ColorAmount); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_ColorAmount, type_name_ColorAmount.to_string(), type_ids_ColorAmount)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "ColorAmount already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_multi_array_struct_type_identifier( - TypeIdentifierPair& type_ids_multi_array_struct) -{ - - ReturnCode_t return_code_multi_array_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_multi_array_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "multi_array_struct", type_ids_multi_array_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_multi_array_struct) - { - StructTypeFlag struct_flags_multi_array_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_multi_array_struct = "multi_array_struct"; - eprosima::fastcdr::optional type_ann_builtin_multi_array_struct; - eprosima::fastcdr::optional ann_custom_multi_array_struct; - CompleteTypeDetail detail_multi_array_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_multi_array_struct, ann_custom_multi_array_struct, type_name_multi_array_struct.to_string()); - CompleteStructHeader header_multi_array_struct; - header_multi_array_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_multi_array_struct); - CompleteStructMemberSeq member_seq_multi_array_struct; - { - TypeIdentifierPair type_ids_colors; - ReturnCode_t return_code_colors {eprosima::fastdds::dds::RETCODE_OK}; - return_code_colors = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_array_ColorAmount_5_5_5", type_ids_colors); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_colors) - { - return_code_colors = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ColorAmount", type_ids_colors); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_colors) - { - ::register_ColorAmount_type_identifier(type_ids_colors); - } - bool element_identifier_anonymous_array_ColorAmount_5_5_5_ec {false}; - TypeIdentifier* element_identifier_anonymous_array_ColorAmount_5_5_5 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_colors, element_identifier_anonymous_array_ColorAmount_5_5_5_ec))}; - if (!element_identifier_anonymous_array_ColorAmount_5_5_5_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_array_ColorAmount_5_5_5 = EK_COMPLETE; - if (TK_NONE == type_ids_colors.type_identifier2()._d()) - { - equiv_kind_anonymous_array_ColorAmount_5_5_5 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_array_ColorAmount_5_5_5 = 0; - PlainCollectionHeader header_anonymous_array_ColorAmount_5_5_5 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_ColorAmount_5_5_5, element_flags_anonymous_array_ColorAmount_5_5_5); - { - SBoundSeq array_bound_seq; - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); - - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); - - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(5)); - - PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_ColorAmount_5_5_5, array_bound_seq, - eprosima::fastcdr::external(element_identifier_anonymous_array_ColorAmount_5_5_5)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_ColorAmount_5_5_5", type_ids_colors)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_array_ColorAmount_5_5_5 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_colors = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_colors = 0x00000000; - bool common_colors_ec {false}; - CommonStructMember common_colors {TypeObjectUtils::build_common_struct_member(member_id_colors, member_flags_colors, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_colors, common_colors_ec))}; - if (!common_colors_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure colors member TypeIdentifier inconsistent."); - return; - } - MemberName name_colors = "colors"; - eprosima::fastcdr::optional member_ann_builtin_colors; - ann_custom_multi_array_struct.reset(); - CompleteMemberDetail detail_colors = TypeObjectUtils::build_complete_member_detail(name_colors, member_ann_builtin_colors, ann_custom_multi_array_struct); - CompleteStructMember member_colors = TypeObjectUtils::build_complete_struct_member(common_colors, detail_colors); - TypeObjectUtils::add_complete_struct_member(member_seq_multi_array_struct, member_colors); - } - CompleteStructType struct_type_multi_array_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_multi_array_struct, header_multi_array_struct, member_seq_multi_array_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_multi_array_struct, type_name_multi_array_struct.to_string(), type_ids_multi_array_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "multi_array_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp deleted file mode 100644 index 41f53fd9e5c..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_struct.hpp +++ /dev/null @@ -1,1031 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_struct.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_HPP -#define FAST_DDS_GENERATED__NESTED_STRUCT_HPP - -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(NESTED_STRUCT_SOURCE) -#define NESTED_STRUCT_DllAPI __declspec( dllexport ) -#else -#define NESTED_STRUCT_DllAPI __declspec( dllimport ) -#endif // NESTED_STRUCT_SOURCE -#else -#define NESTED_STRUCT_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define NESTED_STRUCT_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure FirstStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FirstStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport FirstStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~FirstStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object FirstStruct that will be copied. - */ - eProsima_user_DllExport FirstStruct( - const FirstStruct& x) - { - m_value = x.m_value; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object FirstStruct that will be copied. - */ - eProsima_user_DllExport FirstStruct( - FirstStruct&& x) noexcept - { - m_value = x.m_value; - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object FirstStruct that will be copied. - */ - eProsima_user_DllExport FirstStruct& operator =( - const FirstStruct& x) - { - - m_value = x.m_value; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object FirstStruct that will be copied. - */ - eProsima_user_DllExport FirstStruct& operator =( - FirstStruct&& x) noexcept - { - - m_value = x.m_value; - return *this; - } - - /*! - * @brief Comparison operator. - * @param x FirstStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const FirstStruct& x) const - { - return (m_value == x.m_value); - } - - /*! - * @brief Comparison operator. - * @param x FirstStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const FirstStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function sets a value in member value - * @param _value New value for member value - */ - eProsima_user_DllExport void value( - int32_t _value) - { - m_value = _value; - } - - /*! - * @brief This function returns the value of member value - * @return Value of member value - */ - eProsima_user_DllExport int32_t value() const - { - return m_value; - } - - /*! - * @brief This function returns a reference to member value - * @return Reference to member value - */ - eProsima_user_DllExport int32_t& value() - { - return m_value; - } - - - -private: - - int32_t m_value{0}; - -}; -/*! - * @brief This class represents the structure SecondStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class SecondStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport SecondStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~SecondStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object SecondStruct that will be copied. - */ - eProsima_user_DllExport SecondStruct( - const SecondStruct& x) - { - m_first = x.m_first; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object SecondStruct that will be copied. - */ - eProsima_user_DllExport SecondStruct( - SecondStruct&& x) noexcept - { - m_first = std::move(x.m_first); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object SecondStruct that will be copied. - */ - eProsima_user_DllExport SecondStruct& operator =( - const SecondStruct& x) - { - - m_first = x.m_first; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object SecondStruct that will be copied. - */ - eProsima_user_DllExport SecondStruct& operator =( - SecondStruct&& x) noexcept - { - - m_first = std::move(x.m_first); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x SecondStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const SecondStruct& x) const - { - return (m_first == x.m_first); - } - - /*! - * @brief Comparison operator. - * @param x SecondStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const SecondStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member first - * @param _first New value to be copied in member first - */ - eProsima_user_DllExport void first( - const FirstStruct& _first) - { - m_first = _first; - } - - /*! - * @brief This function moves the value in member first - * @param _first New value to be moved in member first - */ - eProsima_user_DllExport void first( - FirstStruct&& _first) - { - m_first = std::move(_first); - } - - /*! - * @brief This function returns a constant reference to member first - * @return Constant reference to member first - */ - eProsima_user_DllExport const FirstStruct& first() const - { - return m_first; - } - - /*! - * @brief This function returns a reference to member first - * @return Reference to member first - */ - eProsima_user_DllExport FirstStruct& first() - { - return m_first; - } - - - -private: - - FirstStruct m_first; - -}; -/*! - * @brief This class represents the structure ThirdStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class ThirdStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport ThirdStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~ThirdStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object ThirdStruct that will be copied. - */ - eProsima_user_DllExport ThirdStruct( - const ThirdStruct& x) - { - m_second = x.m_second; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object ThirdStruct that will be copied. - */ - eProsima_user_DllExport ThirdStruct( - ThirdStruct&& x) noexcept - { - m_second = std::move(x.m_second); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object ThirdStruct that will be copied. - */ - eProsima_user_DllExport ThirdStruct& operator =( - const ThirdStruct& x) - { - - m_second = x.m_second; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object ThirdStruct that will be copied. - */ - eProsima_user_DllExport ThirdStruct& operator =( - ThirdStruct&& x) noexcept - { - - m_second = std::move(x.m_second); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x ThirdStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const ThirdStruct& x) const - { - return (m_second == x.m_second); - } - - /*! - * @brief Comparison operator. - * @param x ThirdStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const ThirdStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member second - * @param _second New value to be copied in member second - */ - eProsima_user_DllExport void second( - const SecondStruct& _second) - { - m_second = _second; - } - - /*! - * @brief This function moves the value in member second - * @param _second New value to be moved in member second - */ - eProsima_user_DllExport void second( - SecondStruct&& _second) - { - m_second = std::move(_second); - } - - /*! - * @brief This function returns a constant reference to member second - * @return Constant reference to member second - */ - eProsima_user_DllExport const SecondStruct& second() const - { - return m_second; - } - - /*! - * @brief This function returns a reference to member second - * @return Reference to member second - */ - eProsima_user_DllExport SecondStruct& second() - { - return m_second; - } - - - -private: - - SecondStruct m_second; - -}; -/*! - * @brief This class represents the structure FourthStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FourthStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport FourthStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~FourthStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object FourthStruct that will be copied. - */ - eProsima_user_DllExport FourthStruct( - const FourthStruct& x) - { - m_third = x.m_third; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object FourthStruct that will be copied. - */ - eProsima_user_DllExport FourthStruct( - FourthStruct&& x) noexcept - { - m_third = std::move(x.m_third); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object FourthStruct that will be copied. - */ - eProsima_user_DllExport FourthStruct& operator =( - const FourthStruct& x) - { - - m_third = x.m_third; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object FourthStruct that will be copied. - */ - eProsima_user_DllExport FourthStruct& operator =( - FourthStruct&& x) noexcept - { - - m_third = std::move(x.m_third); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x FourthStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const FourthStruct& x) const - { - return (m_third == x.m_third); - } - - /*! - * @brief Comparison operator. - * @param x FourthStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const FourthStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member third - * @param _third New value to be copied in member third - */ - eProsima_user_DllExport void third( - const ThirdStruct& _third) - { - m_third = _third; - } - - /*! - * @brief This function moves the value in member third - * @param _third New value to be moved in member third - */ - eProsima_user_DllExport void third( - ThirdStruct&& _third) - { - m_third = std::move(_third); - } - - /*! - * @brief This function returns a constant reference to member third - * @return Constant reference to member third - */ - eProsima_user_DllExport const ThirdStruct& third() const - { - return m_third; - } - - /*! - * @brief This function returns a reference to member third - * @return Reference to member third - */ - eProsima_user_DllExport ThirdStruct& third() - { - return m_third; - } - - - -private: - - ThirdStruct m_third; - -}; -/*! - * @brief This class represents the structure FifthStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FifthStruct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport FifthStruct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~FifthStruct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object FifthStruct that will be copied. - */ - eProsima_user_DllExport FifthStruct( - const FifthStruct& x) - { - m_fourth = x.m_fourth; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object FifthStruct that will be copied. - */ - eProsima_user_DllExport FifthStruct( - FifthStruct&& x) noexcept - { - m_fourth = std::move(x.m_fourth); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object FifthStruct that will be copied. - */ - eProsima_user_DllExport FifthStruct& operator =( - const FifthStruct& x) - { - - m_fourth = x.m_fourth; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object FifthStruct that will be copied. - */ - eProsima_user_DllExport FifthStruct& operator =( - FifthStruct&& x) noexcept - { - - m_fourth = std::move(x.m_fourth); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x FifthStruct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const FifthStruct& x) const - { - return (m_fourth == x.m_fourth); - } - - /*! - * @brief Comparison operator. - * @param x FifthStruct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const FifthStruct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member fourth - * @param _fourth New value to be copied in member fourth - */ - eProsima_user_DllExport void fourth( - const FourthStruct& _fourth) - { - m_fourth = _fourth; - } - - /*! - * @brief This function moves the value in member fourth - * @param _fourth New value to be moved in member fourth - */ - eProsima_user_DllExport void fourth( - FourthStruct&& _fourth) - { - m_fourth = std::move(_fourth); - } - - /*! - * @brief This function returns a constant reference to member fourth - * @return Constant reference to member fourth - */ - eProsima_user_DllExport const FourthStruct& fourth() const - { - return m_fourth; - } - - /*! - * @brief This function returns a reference to member fourth - * @return Reference to member fourth - */ - eProsima_user_DllExport FourthStruct& fourth() - { - return m_fourth; - } - - - -private: - - FourthStruct m_fourth; - -}; -/*! - * @brief This class represents the structure nested_struct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class nested_struct -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport nested_struct() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~nested_struct() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object nested_struct that will be copied. - */ - eProsima_user_DllExport nested_struct( - const nested_struct& x) - { - m_first = x.m_first; - - m_second = x.m_second; - - m_third = x.m_third; - - m_fourth = x.m_fourth; - - m_fifth = x.m_fifth; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object nested_struct that will be copied. - */ - eProsima_user_DllExport nested_struct( - nested_struct&& x) noexcept - { - m_first = std::move(x.m_first); - m_second = std::move(x.m_second); - m_third = std::move(x.m_third); - m_fourth = std::move(x.m_fourth); - m_fifth = std::move(x.m_fifth); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object nested_struct that will be copied. - */ - eProsima_user_DllExport nested_struct& operator =( - const nested_struct& x) - { - - m_first = x.m_first; - - m_second = x.m_second; - - m_third = x.m_third; - - m_fourth = x.m_fourth; - - m_fifth = x.m_fifth; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object nested_struct that will be copied. - */ - eProsima_user_DllExport nested_struct& operator =( - nested_struct&& x) noexcept - { - - m_first = std::move(x.m_first); - m_second = std::move(x.m_second); - m_third = std::move(x.m_third); - m_fourth = std::move(x.m_fourth); - m_fifth = std::move(x.m_fifth); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x nested_struct object to compare. - */ - eProsima_user_DllExport bool operator ==( - const nested_struct& x) const - { - return (m_first == x.m_first && - m_second == x.m_second && - m_third == x.m_third && - m_fourth == x.m_fourth && - m_fifth == x.m_fifth); - } - - /*! - * @brief Comparison operator. - * @param x nested_struct object to compare. - */ - eProsima_user_DllExport bool operator !=( - const nested_struct& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member first - * @param _first New value to be copied in member first - */ - eProsima_user_DllExport void first( - const FirstStruct& _first) - { - m_first = _first; - } - - /*! - * @brief This function moves the value in member first - * @param _first New value to be moved in member first - */ - eProsima_user_DllExport void first( - FirstStruct&& _first) - { - m_first = std::move(_first); - } - - /*! - * @brief This function returns a constant reference to member first - * @return Constant reference to member first - */ - eProsima_user_DllExport const FirstStruct& first() const - { - return m_first; - } - - /*! - * @brief This function returns a reference to member first - * @return Reference to member first - */ - eProsima_user_DllExport FirstStruct& first() - { - return m_first; - } - - - /*! - * @brief This function copies the value in member second - * @param _second New value to be copied in member second - */ - eProsima_user_DllExport void second( - const SecondStruct& _second) - { - m_second = _second; - } - - /*! - * @brief This function moves the value in member second - * @param _second New value to be moved in member second - */ - eProsima_user_DllExport void second( - SecondStruct&& _second) - { - m_second = std::move(_second); - } - - /*! - * @brief This function returns a constant reference to member second - * @return Constant reference to member second - */ - eProsima_user_DllExport const SecondStruct& second() const - { - return m_second; - } - - /*! - * @brief This function returns a reference to member second - * @return Reference to member second - */ - eProsima_user_DllExport SecondStruct& second() - { - return m_second; - } - - - /*! - * @brief This function copies the value in member third - * @param _third New value to be copied in member third - */ - eProsima_user_DllExport void third( - const ThirdStruct& _third) - { - m_third = _third; - } - - /*! - * @brief This function moves the value in member third - * @param _third New value to be moved in member third - */ - eProsima_user_DllExport void third( - ThirdStruct&& _third) - { - m_third = std::move(_third); - } - - /*! - * @brief This function returns a constant reference to member third - * @return Constant reference to member third - */ - eProsima_user_DllExport const ThirdStruct& third() const - { - return m_third; - } - - /*! - * @brief This function returns a reference to member third - * @return Reference to member third - */ - eProsima_user_DllExport ThirdStruct& third() - { - return m_third; - } - - - /*! - * @brief This function copies the value in member fourth - * @param _fourth New value to be copied in member fourth - */ - eProsima_user_DllExport void fourth( - const FourthStruct& _fourth) - { - m_fourth = _fourth; - } - - /*! - * @brief This function moves the value in member fourth - * @param _fourth New value to be moved in member fourth - */ - eProsima_user_DllExport void fourth( - FourthStruct&& _fourth) - { - m_fourth = std::move(_fourth); - } - - /*! - * @brief This function returns a constant reference to member fourth - * @return Constant reference to member fourth - */ - eProsima_user_DllExport const FourthStruct& fourth() const - { - return m_fourth; - } - - /*! - * @brief This function returns a reference to member fourth - * @return Reference to member fourth - */ - eProsima_user_DllExport FourthStruct& fourth() - { - return m_fourth; - } - - - /*! - * @brief This function copies the value in member fifth - * @param _fifth New value to be copied in member fifth - */ - eProsima_user_DllExport void fifth( - const FifthStruct& _fifth) - { - m_fifth = _fifth; - } - - /*! - * @brief This function moves the value in member fifth - * @param _fifth New value to be moved in member fifth - */ - eProsima_user_DllExport void fifth( - FifthStruct&& _fifth) - { - m_fifth = std::move(_fifth); - } - - /*! - * @brief This function returns a constant reference to member fifth - * @return Constant reference to member fifth - */ - eProsima_user_DllExport const FifthStruct& fifth() const - { - return m_fifth; - } - - /*! - * @brief This function returns a reference to member fifth - * @return Reference to member fifth - */ - eProsima_user_DllExport FifthStruct& fifth() - { - return m_fifth; - } - - - -private: - - FirstStruct m_first; - SecondStruct m_second; - ThirdStruct m_third; - FourthStruct m_fourth; - FifthStruct m_fifth; - -}; - -#endif // _FAST_DDS_GENERATED_NESTED_STRUCT_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp deleted file mode 100644 index 4c2cf3198cb..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.hpp +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP -#define FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP - -#include "nested_struct.hpp" - -constexpr uint32_t FirstStruct_max_cdr_typesize {8UL}; -constexpr uint32_t FirstStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t SecondStruct_max_cdr_typesize {12UL}; -constexpr uint32_t SecondStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t FifthStruct_max_cdr_typesize {24UL}; -constexpr uint32_t FifthStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t nested_struct_max_cdr_typesize {84UL}; -constexpr uint32_t nested_struct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t ThirdStruct_max_cdr_typesize {16UL}; -constexpr uint32_t ThirdStruct_max_key_cdr_typesize {0UL}; - -constexpr uint32_t FourthStruct_max_cdr_typesize {20UL}; -constexpr uint32_t FourthStruct_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FirstStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const SecondStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const ThirdStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FourthStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FifthStruct& data); - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const nested_struct& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp deleted file mode 100644 index 404af3c8ac0..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structCdrAux.ipp +++ /dev/null @@ -1,530 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP - -#include "nested_structCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const FirstStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.value(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const FirstStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.value() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - FirstStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.value(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FirstStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const SecondStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.first(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const SecondStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.first() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - SecondStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.first(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const SecondStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const ThirdStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.second(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const ThirdStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.second() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - ThirdStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.second(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const ThirdStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const FourthStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.third(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const FourthStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.third() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - FourthStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.third(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FourthStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const FifthStruct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.fourth(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const FifthStruct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.fourth() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - FifthStruct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.fourth(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const FifthStruct& data) -{ - static_cast(scdr); - static_cast(data); -} - - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const nested_struct& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.first(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.second(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.third(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.fourth(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), - data.fifth(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const nested_struct& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.first() - << eprosima::fastcdr::MemberId(1) << data.second() - << eprosima::fastcdr::MemberId(2) << data.third() - << eprosima::fastcdr::MemberId(3) << data.fourth() - << eprosima::fastcdr::MemberId(4) << data.fifth() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - nested_struct& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.first(); - break; - - case 1: - dcdr >> data.second(); - break; - - case 2: - dcdr >> data.third(); - break; - - case 3: - dcdr >> data.fourth(); - break; - - case 4: - dcdr >> data.fifth(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const nested_struct& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__NESTED_STRUCTCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx deleted file mode 100644 index 109072bb202..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.cxx +++ /dev/null @@ -1,1194 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "nested_structPubSubTypes.hpp" - -#include -#include - -#include "nested_structCdrAux.hpp" -#include "nested_structTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -FirstStructPubSubType::FirstStructPubSubType() -{ - setName("FirstStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(FirstStruct::getMaxCdrSerializedSize()); -#else - FirstStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = FirstStruct_max_key_cdr_typesize > 16 ? FirstStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -FirstStructPubSubType::~FirstStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool FirstStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const FirstStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool FirstStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - FirstStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function FirstStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* FirstStructPubSubType::createData() -{ - return reinterpret_cast(new FirstStruct()); -} - -void FirstStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool FirstStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const FirstStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - FirstStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || FirstStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void FirstStructPubSubType::register_type_object_representation() -{ - register_FirstStruct_type_identifier(type_identifiers_); -} - -SecondStructPubSubType::SecondStructPubSubType() -{ - setName("SecondStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(SecondStruct::getMaxCdrSerializedSize()); -#else - SecondStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = SecondStruct_max_key_cdr_typesize > 16 ? SecondStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -SecondStructPubSubType::~SecondStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool SecondStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const SecondStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool SecondStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - SecondStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function SecondStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* SecondStructPubSubType::createData() -{ - return reinterpret_cast(new SecondStruct()); -} - -void SecondStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool SecondStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const SecondStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - SecondStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || SecondStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void SecondStructPubSubType::register_type_object_representation() -{ - register_SecondStruct_type_identifier(type_identifiers_); -} - -ThirdStructPubSubType::ThirdStructPubSubType() -{ - setName("ThirdStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(ThirdStruct::getMaxCdrSerializedSize()); -#else - ThirdStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = ThirdStruct_max_key_cdr_typesize > 16 ? ThirdStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -ThirdStructPubSubType::~ThirdStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool ThirdStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const ThirdStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool ThirdStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - ThirdStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function ThirdStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* ThirdStructPubSubType::createData() -{ - return reinterpret_cast(new ThirdStruct()); -} - -void ThirdStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool ThirdStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const ThirdStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - ThirdStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || ThirdStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void ThirdStructPubSubType::register_type_object_representation() -{ - register_ThirdStruct_type_identifier(type_identifiers_); -} - -FourthStructPubSubType::FourthStructPubSubType() -{ - setName("FourthStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(FourthStruct::getMaxCdrSerializedSize()); -#else - FourthStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = FourthStruct_max_key_cdr_typesize > 16 ? FourthStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -FourthStructPubSubType::~FourthStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool FourthStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const FourthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool FourthStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - FourthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function FourthStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* FourthStructPubSubType::createData() -{ - return reinterpret_cast(new FourthStruct()); -} - -void FourthStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool FourthStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const FourthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - FourthStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || FourthStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void FourthStructPubSubType::register_type_object_representation() -{ - register_FourthStruct_type_identifier(type_identifiers_); -} - -FifthStructPubSubType::FifthStructPubSubType() -{ - setName("FifthStruct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(FifthStruct::getMaxCdrSerializedSize()); -#else - FifthStruct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = FifthStruct_max_key_cdr_typesize > 16 ? FifthStruct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -FifthStructPubSubType::~FifthStructPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool FifthStructPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const FifthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool FifthStructPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - FifthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function FifthStructPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* FifthStructPubSubType::createData() -{ - return reinterpret_cast(new FifthStruct()); -} - -void FifthStructPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool FifthStructPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const FifthStruct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - FifthStruct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || FifthStruct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void FifthStructPubSubType::register_type_object_representation() -{ - register_FifthStruct_type_identifier(type_identifiers_); -} - -nested_structPubSubType::nested_structPubSubType() -{ - setName("nested_struct"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(nested_struct::getMaxCdrSerializedSize()); -#else - nested_struct_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = nested_struct_max_key_cdr_typesize > 16 ? nested_struct_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -nested_structPubSubType::~nested_structPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool nested_structPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const nested_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool nested_structPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - nested_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function nested_structPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* nested_structPubSubType::createData() -{ - return reinterpret_cast(new nested_struct()); -} - -void nested_structPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool nested_structPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const nested_struct* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - nested_struct_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || nested_struct_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void nested_structPubSubType::register_type_object_representation() -{ - register_nested_struct_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "nested_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp deleted file mode 100644 index a86ece59af0..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structPubSubTypes.hpp +++ /dev/null @@ -1,588 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "nested_struct.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated nested_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type FirstStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FirstStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef FirstStruct type; - - eProsima_user_DllExport FirstStructPubSubType(); - - eProsima_user_DllExport ~FirstStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type SecondStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class SecondStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef SecondStruct type; - - eProsima_user_DllExport SecondStructPubSubType(); - - eProsima_user_DllExport ~SecondStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type ThirdStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class ThirdStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef ThirdStruct type; - - eProsima_user_DllExport ThirdStructPubSubType(); - - eProsima_user_DllExport ~ThirdStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type FourthStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FourthStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef FourthStruct type; - - eProsima_user_DllExport FourthStructPubSubType(); - - eProsima_user_DllExport ~FourthStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type FifthStruct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class FifthStructPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef FifthStruct type; - - eProsima_user_DllExport FifthStructPubSubType(); - - eProsima_user_DllExport ~FifthStructPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -/*! - * @brief This class represents the TopicDataType of the type nested_struct defined by the user in the IDL file. - * @ingroup nested_struct - */ -class nested_structPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef nested_struct type; - - eProsima_user_DllExport nested_structPubSubType(); - - eProsima_user_DllExport ~nested_structPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__NESTED_STRUCT_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx deleted file mode 100644 index 25e48396516..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.cxx +++ /dev/null @@ -1,497 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "nested_structTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "nested_struct.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_FirstStruct_type_identifier( - TypeIdentifierPair& type_ids_FirstStruct) -{ - - ReturnCode_t return_code_FirstStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_FirstStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FirstStruct", type_ids_FirstStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_FirstStruct) - { - StructTypeFlag struct_flags_FirstStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_FirstStruct = "FirstStruct"; - eprosima::fastcdr::optional type_ann_builtin_FirstStruct; - eprosima::fastcdr::optional ann_custom_FirstStruct; - CompleteTypeDetail detail_FirstStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FirstStruct, ann_custom_FirstStruct, type_name_FirstStruct.to_string()); - CompleteStructHeader header_FirstStruct; - header_FirstStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FirstStruct); - CompleteStructMemberSeq member_seq_FirstStruct; - { - TypeIdentifierPair type_ids_value; - ReturnCode_t return_code_value {eprosima::fastdds::dds::RETCODE_OK}; - return_code_value = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_value); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_value) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "value Structure member TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - StructMemberFlag member_flags_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_value = 0x00000000; - bool common_value_ec {false}; - CommonStructMember common_value {TypeObjectUtils::build_common_struct_member(member_id_value, member_flags_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_value, common_value_ec))}; - if (!common_value_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure value member TypeIdentifier inconsistent."); - return; - } - MemberName name_value = "value"; - eprosima::fastcdr::optional member_ann_builtin_value; - ann_custom_FirstStruct.reset(); - CompleteMemberDetail detail_value = TypeObjectUtils::build_complete_member_detail(name_value, member_ann_builtin_value, ann_custom_FirstStruct); - CompleteStructMember member_value = TypeObjectUtils::build_complete_struct_member(common_value, detail_value); - TypeObjectUtils::add_complete_struct_member(member_seq_FirstStruct, member_value); - } - CompleteStructType struct_type_FirstStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FirstStruct, header_FirstStruct, member_seq_FirstStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_FirstStruct, type_name_FirstStruct.to_string(), type_ids_FirstStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FirstStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_SecondStruct_type_identifier( - TypeIdentifierPair& type_ids_SecondStruct) -{ - - ReturnCode_t return_code_SecondStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_SecondStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SecondStruct", type_ids_SecondStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_SecondStruct) - { - StructTypeFlag struct_flags_SecondStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_SecondStruct = "SecondStruct"; - eprosima::fastcdr::optional type_ann_builtin_SecondStruct; - eprosima::fastcdr::optional ann_custom_SecondStruct; - CompleteTypeDetail detail_SecondStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SecondStruct, ann_custom_SecondStruct, type_name_SecondStruct.to_string()); - CompleteStructHeader header_SecondStruct; - header_SecondStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SecondStruct); - CompleteStructMemberSeq member_seq_SecondStruct; - { - TypeIdentifierPair type_ids_first; - ReturnCode_t return_code_first {eprosima::fastdds::dds::RETCODE_OK}; - return_code_first = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FirstStruct", type_ids_first); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_first) - { - ::register_FirstStruct_type_identifier(type_ids_first); - } - StructMemberFlag member_flags_first = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_first = 0x00000000; - bool common_first_ec {false}; - CommonStructMember common_first {TypeObjectUtils::build_common_struct_member(member_id_first, member_flags_first, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_first, common_first_ec))}; - if (!common_first_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure first member TypeIdentifier inconsistent."); - return; - } - MemberName name_first = "first"; - eprosima::fastcdr::optional member_ann_builtin_first; - ann_custom_SecondStruct.reset(); - CompleteMemberDetail detail_first = TypeObjectUtils::build_complete_member_detail(name_first, member_ann_builtin_first, ann_custom_SecondStruct); - CompleteStructMember member_first = TypeObjectUtils::build_complete_struct_member(common_first, detail_first); - TypeObjectUtils::add_complete_struct_member(member_seq_SecondStruct, member_first); - } - CompleteStructType struct_type_SecondStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_SecondStruct, header_SecondStruct, member_seq_SecondStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_SecondStruct, type_name_SecondStruct.to_string(), type_ids_SecondStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "SecondStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_ThirdStruct_type_identifier( - TypeIdentifierPair& type_ids_ThirdStruct) -{ - - ReturnCode_t return_code_ThirdStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_ThirdStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdStruct", type_ids_ThirdStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_ThirdStruct) - { - StructTypeFlag struct_flags_ThirdStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_ThirdStruct = "ThirdStruct"; - eprosima::fastcdr::optional type_ann_builtin_ThirdStruct; - eprosima::fastcdr::optional ann_custom_ThirdStruct; - CompleteTypeDetail detail_ThirdStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ThirdStruct, ann_custom_ThirdStruct, type_name_ThirdStruct.to_string()); - CompleteStructHeader header_ThirdStruct; - header_ThirdStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ThirdStruct); - CompleteStructMemberSeq member_seq_ThirdStruct; - { - TypeIdentifierPair type_ids_second; - ReturnCode_t return_code_second {eprosima::fastdds::dds::RETCODE_OK}; - return_code_second = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SecondStruct", type_ids_second); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_second) - { - ::register_SecondStruct_type_identifier(type_ids_second); - } - StructMemberFlag member_flags_second = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_second = 0x00000000; - bool common_second_ec {false}; - CommonStructMember common_second {TypeObjectUtils::build_common_struct_member(member_id_second, member_flags_second, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_second, common_second_ec))}; - if (!common_second_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure second member TypeIdentifier inconsistent."); - return; - } - MemberName name_second = "second"; - eprosima::fastcdr::optional member_ann_builtin_second; - ann_custom_ThirdStruct.reset(); - CompleteMemberDetail detail_second = TypeObjectUtils::build_complete_member_detail(name_second, member_ann_builtin_second, ann_custom_ThirdStruct); - CompleteStructMember member_second = TypeObjectUtils::build_complete_struct_member(common_second, detail_second); - TypeObjectUtils::add_complete_struct_member(member_seq_ThirdStruct, member_second); - } - CompleteStructType struct_type_ThirdStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ThirdStruct, header_ThirdStruct, member_seq_ThirdStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_ThirdStruct, type_name_ThirdStruct.to_string(), type_ids_ThirdStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "ThirdStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_FourthStruct_type_identifier( - TypeIdentifierPair& type_ids_FourthStruct) -{ - - ReturnCode_t return_code_FourthStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_FourthStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FourthStruct", type_ids_FourthStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_FourthStruct) - { - StructTypeFlag struct_flags_FourthStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_FourthStruct = "FourthStruct"; - eprosima::fastcdr::optional type_ann_builtin_FourthStruct; - eprosima::fastcdr::optional ann_custom_FourthStruct; - CompleteTypeDetail detail_FourthStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FourthStruct, ann_custom_FourthStruct, type_name_FourthStruct.to_string()); - CompleteStructHeader header_FourthStruct; - header_FourthStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FourthStruct); - CompleteStructMemberSeq member_seq_FourthStruct; - { - TypeIdentifierPair type_ids_third; - ReturnCode_t return_code_third {eprosima::fastdds::dds::RETCODE_OK}; - return_code_third = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdStruct", type_ids_third); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_third) - { - ::register_ThirdStruct_type_identifier(type_ids_third); - } - StructMemberFlag member_flags_third = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_third = 0x00000000; - bool common_third_ec {false}; - CommonStructMember common_third {TypeObjectUtils::build_common_struct_member(member_id_third, member_flags_third, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_third, common_third_ec))}; - if (!common_third_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure third member TypeIdentifier inconsistent."); - return; - } - MemberName name_third = "third"; - eprosima::fastcdr::optional member_ann_builtin_third; - ann_custom_FourthStruct.reset(); - CompleteMemberDetail detail_third = TypeObjectUtils::build_complete_member_detail(name_third, member_ann_builtin_third, ann_custom_FourthStruct); - CompleteStructMember member_third = TypeObjectUtils::build_complete_struct_member(common_third, detail_third); - TypeObjectUtils::add_complete_struct_member(member_seq_FourthStruct, member_third); - } - CompleteStructType struct_type_FourthStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FourthStruct, header_FourthStruct, member_seq_FourthStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_FourthStruct, type_name_FourthStruct.to_string(), type_ids_FourthStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FourthStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_FifthStruct_type_identifier( - TypeIdentifierPair& type_ids_FifthStruct) -{ - - ReturnCode_t return_code_FifthStruct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_FifthStruct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FifthStruct", type_ids_FifthStruct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_FifthStruct) - { - StructTypeFlag struct_flags_FifthStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_FifthStruct = "FifthStruct"; - eprosima::fastcdr::optional type_ann_builtin_FifthStruct; - eprosima::fastcdr::optional ann_custom_FifthStruct; - CompleteTypeDetail detail_FifthStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_FifthStruct, ann_custom_FifthStruct, type_name_FifthStruct.to_string()); - CompleteStructHeader header_FifthStruct; - header_FifthStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_FifthStruct); - CompleteStructMemberSeq member_seq_FifthStruct; - { - TypeIdentifierPair type_ids_fourth; - ReturnCode_t return_code_fourth {eprosima::fastdds::dds::RETCODE_OK}; - return_code_fourth = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FourthStruct", type_ids_fourth); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_fourth) - { - ::register_FourthStruct_type_identifier(type_ids_fourth); - } - StructMemberFlag member_flags_fourth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_fourth = 0x00000000; - bool common_fourth_ec {false}; - CommonStructMember common_fourth {TypeObjectUtils::build_common_struct_member(member_id_fourth, member_flags_fourth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fourth, common_fourth_ec))}; - if (!common_fourth_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fourth member TypeIdentifier inconsistent."); - return; - } - MemberName name_fourth = "fourth"; - eprosima::fastcdr::optional member_ann_builtin_fourth; - ann_custom_FifthStruct.reset(); - CompleteMemberDetail detail_fourth = TypeObjectUtils::build_complete_member_detail(name_fourth, member_ann_builtin_fourth, ann_custom_FifthStruct); - CompleteStructMember member_fourth = TypeObjectUtils::build_complete_struct_member(common_fourth, detail_fourth); - TypeObjectUtils::add_complete_struct_member(member_seq_FifthStruct, member_fourth); - } - CompleteStructType struct_type_FifthStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_FifthStruct, header_FifthStruct, member_seq_FifthStruct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_FifthStruct, type_name_FifthStruct.to_string(), type_ids_FifthStruct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "FifthStruct already registered in TypeObjectRegistry for a different type."); - } - } -} -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_nested_struct_type_identifier( - TypeIdentifierPair& type_ids_nested_struct) -{ - - ReturnCode_t return_code_nested_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_nested_struct = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "nested_struct", type_ids_nested_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_nested_struct) - { - StructTypeFlag struct_flags_nested_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_nested_struct = "nested_struct"; - eprosima::fastcdr::optional type_ann_builtin_nested_struct; - eprosima::fastcdr::optional ann_custom_nested_struct; - CompleteTypeDetail detail_nested_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_nested_struct, ann_custom_nested_struct, type_name_nested_struct.to_string()); - CompleteStructHeader header_nested_struct; - header_nested_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_nested_struct); - CompleteStructMemberSeq member_seq_nested_struct; - { - TypeIdentifierPair type_ids_first; - ReturnCode_t return_code_first {eprosima::fastdds::dds::RETCODE_OK}; - return_code_first = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FirstStruct", type_ids_first); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_first) - { - ::register_FirstStruct_type_identifier(type_ids_first); - } - StructMemberFlag member_flags_first = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_first = 0x00000000; - bool common_first_ec {false}; - CommonStructMember common_first {TypeObjectUtils::build_common_struct_member(member_id_first, member_flags_first, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_first, common_first_ec))}; - if (!common_first_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure first member TypeIdentifier inconsistent."); - return; - } - MemberName name_first = "first"; - eprosima::fastcdr::optional member_ann_builtin_first; - ann_custom_nested_struct.reset(); - CompleteMemberDetail detail_first = TypeObjectUtils::build_complete_member_detail(name_first, member_ann_builtin_first, ann_custom_nested_struct); - CompleteStructMember member_first = TypeObjectUtils::build_complete_struct_member(common_first, detail_first); - TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_first); - } - { - TypeIdentifierPair type_ids_second; - ReturnCode_t return_code_second {eprosima::fastdds::dds::RETCODE_OK}; - return_code_second = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "SecondStruct", type_ids_second); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_second) - { - ::register_SecondStruct_type_identifier(type_ids_second); - } - StructMemberFlag member_flags_second = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_second = 0x00000001; - bool common_second_ec {false}; - CommonStructMember common_second {TypeObjectUtils::build_common_struct_member(member_id_second, member_flags_second, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_second, common_second_ec))}; - if (!common_second_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure second member TypeIdentifier inconsistent."); - return; - } - MemberName name_second = "second"; - eprosima::fastcdr::optional member_ann_builtin_second; - ann_custom_nested_struct.reset(); - CompleteMemberDetail detail_second = TypeObjectUtils::build_complete_member_detail(name_second, member_ann_builtin_second, ann_custom_nested_struct); - CompleteStructMember member_second = TypeObjectUtils::build_complete_struct_member(common_second, detail_second); - TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_second); - } - { - TypeIdentifierPair type_ids_third; - ReturnCode_t return_code_third {eprosima::fastdds::dds::RETCODE_OK}; - return_code_third = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "ThirdStruct", type_ids_third); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_third) - { - ::register_ThirdStruct_type_identifier(type_ids_third); - } - StructMemberFlag member_flags_third = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_third = 0x00000002; - bool common_third_ec {false}; - CommonStructMember common_third {TypeObjectUtils::build_common_struct_member(member_id_third, member_flags_third, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_third, common_third_ec))}; - if (!common_third_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure third member TypeIdentifier inconsistent."); - return; - } - MemberName name_third = "third"; - eprosima::fastcdr::optional member_ann_builtin_third; - ann_custom_nested_struct.reset(); - CompleteMemberDetail detail_third = TypeObjectUtils::build_complete_member_detail(name_third, member_ann_builtin_third, ann_custom_nested_struct); - CompleteStructMember member_third = TypeObjectUtils::build_complete_struct_member(common_third, detail_third); - TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_third); - } - { - TypeIdentifierPair type_ids_fourth; - ReturnCode_t return_code_fourth {eprosima::fastdds::dds::RETCODE_OK}; - return_code_fourth = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FourthStruct", type_ids_fourth); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_fourth) - { - ::register_FourthStruct_type_identifier(type_ids_fourth); - } - StructMemberFlag member_flags_fourth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_fourth = 0x00000003; - bool common_fourth_ec {false}; - CommonStructMember common_fourth {TypeObjectUtils::build_common_struct_member(member_id_fourth, member_flags_fourth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fourth, common_fourth_ec))}; - if (!common_fourth_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fourth member TypeIdentifier inconsistent."); - return; - } - MemberName name_fourth = "fourth"; - eprosima::fastcdr::optional member_ann_builtin_fourth; - ann_custom_nested_struct.reset(); - CompleteMemberDetail detail_fourth = TypeObjectUtils::build_complete_member_detail(name_fourth, member_ann_builtin_fourth, ann_custom_nested_struct); - CompleteStructMember member_fourth = TypeObjectUtils::build_complete_struct_member(common_fourth, detail_fourth); - TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_fourth); - } - { - TypeIdentifierPair type_ids_fifth; - ReturnCode_t return_code_fifth {eprosima::fastdds::dds::RETCODE_OK}; - return_code_fifth = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "FifthStruct", type_ids_fifth); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_fifth) - { - ::register_FifthStruct_type_identifier(type_ids_fifth); - } - StructMemberFlag member_flags_fifth = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_fifth = 0x00000004; - bool common_fifth_ec {false}; - CommonStructMember common_fifth {TypeObjectUtils::build_common_struct_member(member_id_fifth, member_flags_fifth, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_fifth, common_fifth_ec))}; - if (!common_fifth_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure fifth member TypeIdentifier inconsistent."); - return; - } - MemberName name_fifth = "fifth"; - eprosima::fastcdr::optional member_ann_builtin_fifth; - ann_custom_nested_struct.reset(); - CompleteMemberDetail detail_fifth = TypeObjectUtils::build_complete_member_detail(name_fifth, member_ann_builtin_fifth, ann_custom_nested_struct); - CompleteStructMember member_fifth = TypeObjectUtils::build_complete_struct_member(common_fifth, detail_fifth); - TypeObjectUtils::add_complete_struct_member(member_seq_nested_struct, member_fifth); - } - CompleteStructType struct_type_nested_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_nested_struct, header_nested_struct, member_seq_nested_struct); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_nested_struct, type_name_nested_struct.to_string(), type_ids_nested_struct)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "nested_struct already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp deleted file mode 100644 index 2117b2f0127..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/nested_struct/nested_structTypeObjectSupport.hpp +++ /dev/null @@ -1,116 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file nested_structTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register FirstStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_FirstStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register SecondStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_SecondStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register ThirdStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_ThirdStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register FourthStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_FourthStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register FifthStruct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_FifthStruct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); -/** - * @brief Register nested_struct related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_nested_struct_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__NESTED_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp deleted file mode 100644 index a78917adcfb..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_array.hpp +++ /dev/null @@ -1,189 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_array.hpp - * This header file contains the declaration of the described types in the IDL file. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_HPP -#define FAST_DDS_GENERATED__NUMERIC_ARRAY_HPP - -#include -#include -#include - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#if defined(NUMERIC_ARRAY_SOURCE) -#define NUMERIC_ARRAY_DllAPI __declspec( dllexport ) -#else -#define NUMERIC_ARRAY_DllAPI __declspec( dllimport ) -#endif // NUMERIC_ARRAY_SOURCE -#else -#define NUMERIC_ARRAY_DllAPI -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define NUMERIC_ARRAY_DllAPI -#endif // _WIN32 - -/*! - * @brief This class represents the structure numeric_array defined by the user in the IDL file. - * @ingroup numeric_array - */ -class numeric_array -{ -public: - - /*! - * @brief Default constructor. - */ - eProsima_user_DllExport numeric_array() - { - } - - /*! - * @brief Default destructor. - */ - eProsima_user_DllExport ~numeric_array() - { - } - - /*! - * @brief Copy constructor. - * @param x Reference to the object numeric_array that will be copied. - */ - eProsima_user_DllExport numeric_array( - const numeric_array& x) - { - m_points = x.m_points; - - } - - /*! - * @brief Move constructor. - * @param x Reference to the object numeric_array that will be copied. - */ - eProsima_user_DllExport numeric_array( - numeric_array&& x) noexcept - { - m_points = std::move(x.m_points); - } - - /*! - * @brief Copy assignment. - * @param x Reference to the object numeric_array that will be copied. - */ - eProsima_user_DllExport numeric_array& operator =( - const numeric_array& x) - { - - m_points = x.m_points; - - return *this; - } - - /*! - * @brief Move assignment. - * @param x Reference to the object numeric_array that will be copied. - */ - eProsima_user_DllExport numeric_array& operator =( - numeric_array&& x) noexcept - { - - m_points = std::move(x.m_points); - return *this; - } - - /*! - * @brief Comparison operator. - * @param x numeric_array object to compare. - */ - eProsima_user_DllExport bool operator ==( - const numeric_array& x) const - { - return (m_points == x.m_points); - } - - /*! - * @brief Comparison operator. - * @param x numeric_array object to compare. - */ - eProsima_user_DllExport bool operator !=( - const numeric_array& x) const - { - return !(*this == x); - } - - /*! - * @brief This function copies the value in member points - * @param _points New value to be copied in member points - */ - eProsima_user_DllExport void points( - const std::array& _points) - { - m_points = _points; - } - - /*! - * @brief This function moves the value in member points - * @param _points New value to be moved in member points - */ - eProsima_user_DllExport void points( - std::array&& _points) - { - m_points = std::move(_points); - } - - /*! - * @brief This function returns a constant reference to member points - * @return Constant reference to member points - */ - eProsima_user_DllExport const std::array& points() const - { - return m_points; - } - - /*! - * @brief This function returns a reference to member points - * @return Reference to member points - */ - eProsima_user_DllExport std::array& points() - { - return m_points; - } - - - -private: - - std::array m_points{0}; - -}; - -#endif // _FAST_DDS_GENERATED_NUMERIC_ARRAY_HPP_ - - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp deleted file mode 100644 index a00c7007b8f..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayCdrAux.hpp - * This source file contains some definitions of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP -#define FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP - -#include "numeric_array.hpp" - -constexpr uint32_t numeric_array_max_cdr_typesize {16UL}; -constexpr uint32_t numeric_array_max_key_cdr_typesize {0UL}; - - -namespace eprosima { -namespace fastcdr { - -class Cdr; -class CdrSizeCalculator; - -eProsima_user_DllExport void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const numeric_array& data); - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp deleted file mode 100644 index a6c384ed34e..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayCdrAux.ipp +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayCdrAux.ipp - * This source file contains some declarations of CDR related functions. - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP -#define FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP - -#include "numeric_arrayCdrAux.hpp" - -#include -#include - - -#include -using namespace eprosima::fastcdr::exception; - -namespace eprosima { -namespace fastcdr { - -template<> -eProsima_user_DllExport size_t calculate_serialized_size( - eprosima::fastcdr::CdrSizeCalculator& calculator, - const numeric_array& data, - size_t& current_alignment) -{ - static_cast(data); - - eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); - size_t calculated_size {calculator.begin_calculate_type_serialized_size( - eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - current_alignment)}; - - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.points(), current_alignment); - - - calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); - - return calculated_size; -} - -template<> -eProsima_user_DllExport void serialize( - eprosima::fastcdr::Cdr& scdr, - const numeric_array& data) -{ - eprosima::fastcdr::Cdr::state current_state(scdr); - scdr.begin_serialize_type(current_state, - eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); - - scdr - << eprosima::fastcdr::MemberId(0) << data.points() -; - scdr.end_serialize_type(current_state); -} - -template<> -eProsima_user_DllExport void deserialize( - eprosima::fastcdr::Cdr& cdr, - numeric_array& data) -{ - cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, - [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool - { - bool ret_value = true; - switch (mid.id) - { - case 0: - dcdr >> data.points(); - break; - - default: - ret_value = false; - break; - } - return ret_value; - }); -} - -void serialize_key( - eprosima::fastcdr::Cdr& scdr, - const numeric_array& data) -{ - static_cast(scdr); - static_cast(data); -} - - - -} // namespace fastcdr -} // namespace eprosima - -#endif // FAST_DDS_GENERATED__NUMERIC_ARRAYCDRAUX_IPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx deleted file mode 100644 index 66b7701c2d5..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.cxx +++ /dev/null @@ -1,229 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayPubSubTypes.cpp - * This header file contains the implementation of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - -#include "numeric_arrayPubSubTypes.hpp" - -#include -#include - -#include "numeric_arrayCdrAux.hpp" -#include "numeric_arrayTypeObjectSupport.hpp" - -using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; -using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; -using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; - -numeric_arrayPubSubType::numeric_arrayPubSubType() -{ - setName("numeric_array"); - uint32_t type_size = -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(numeric_array::getMaxCdrSerializedSize()); -#else - numeric_array_max_cdr_typesize; -#endif - type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ - m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = numeric_array_max_key_cdr_typesize > 16 ? numeric_array_max_key_cdr_typesize : 16; - m_keyBuffer = reinterpret_cast(malloc(keyLength)); - memset(m_keyBuffer, 0, keyLength); -} - -numeric_arrayPubSubType::~numeric_arrayPubSubType() -{ - if (m_keyBuffer != nullptr) - { - free(m_keyBuffer); - } -} - -bool numeric_arrayPubSubType::serialize( - const void* const data, - SerializedPayload_t* payload, - DataRepresentationId_t data_representation) -{ - const numeric_array* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); - payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; -#if FASTCDR_VERSION_MAJOR > 1 - ser.set_encoding_flag( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : - eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); -#endif // FASTCDR_VERSION_MAJOR > 1 - - try - { - // Serialize encapsulation - ser.serialize_encapsulation(); - // Serialize the object. - ser << *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - // Get the serialized length -#if FASTCDR_VERSION_MAJOR == 1 - payload->length = static_cast(ser.getSerializedDataLength()); -#else - payload->length = static_cast(ser.get_serialized_data_length()); -#endif // FASTCDR_VERSION_MAJOR == 1 - return true; -} - -bool numeric_arrayPubSubType::deserialize( - SerializedPayload_t* payload, - void* data) -{ - try - { - // Convert DATA to pointer of your type - numeric_array* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); - - // Object that deserializes the data. - eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN -#if FASTCDR_VERSION_MAJOR == 1 - , eprosima::fastcdr::Cdr::CdrType::DDS_CDR -#endif // FASTCDR_VERSION_MAJOR == 1 - ); - - // Deserialize encapsulation. - deser.read_encapsulation(); - payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; - - // Deserialize the object. - deser >> *p_type; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return false; - } - - return true; -} - -std::function numeric_arrayPubSubType::getSerializedSizeProvider( - const void* const data, - DataRepresentationId_t data_representation) -{ - return [data, data_representation]() -> uint32_t - { -#if FASTCDR_VERSION_MAJOR == 1 - static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + - 4u /*encapsulation*/; -#else - try - { - eprosima::fastcdr::CdrSizeCalculator calculator( - data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? - eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); - size_t current_alignment {0}; - return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + - 4u /*encapsulation*/; - } - catch (eprosima::fastcdr::exception::Exception& /*exception*/) - { - return 0; - } -#endif // FASTCDR_VERSION_MAJOR == 1 - }; -} - -void* numeric_arrayPubSubType::createData() -{ - return reinterpret_cast(new numeric_array()); -} - -void numeric_arrayPubSubType::deleteData( - void* data) -{ - delete(reinterpret_cast(data)); -} - -bool numeric_arrayPubSubType::getKey( - const void* const data, - InstanceHandle_t* handle, - bool force_md5) -{ - if (!m_isGetKeyDefined) - { - return false; - } - - const numeric_array* p_type = static_cast(data); - - // Object that manages the raw buffer. - eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - numeric_array_max_key_cdr_typesize); - - // Object that serializes the data. - eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); -#if FASTCDR_VERSION_MAJOR == 1 - p_type->serializeKey(ser); -#else - eprosima::fastcdr::serialize_key(ser, *p_type); -#endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || numeric_array_max_key_cdr_typesize > 16) - { - m_md5.init(); -#if FASTCDR_VERSION_MAJOR == 1 - m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); -#else - m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); -#endif // FASTCDR_VERSION_MAJOR == 1 - m_md5.finalize(); - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_md5.digest[i]; - } - } - else - { - for (uint8_t i = 0; i < 16; ++i) - { - handle->value[i] = m_keyBuffer[i]; - } - } - return true; -} - -void numeric_arrayPubSubType::register_type_object_representation() -{ - register_numeric_array_type_identifier(type_identifiers_); -} - - -// Include auxiliary functions like for serializing/deserializing. -#include "numeric_arrayCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp deleted file mode 100644 index d65cea0be06..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayPubSubTypes.hpp +++ /dev/null @@ -1,133 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayPubSubTypes.hpp - * This header file contains the declaration of the serialization functions. - * - * This file was generated by the tool fastddsgen. - */ - - -#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP - -#include -#include -#include -#include -#include - -#include "numeric_array.hpp" - - -#if !defined(GEN_API_VER) || (GEN_API_VER != 2) -#error \ - Generated numeric_array is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. -#endif // GEN_API_VER - - -/*! - * @brief This class represents the TopicDataType of the type numeric_array defined by the user in the IDL file. - * @ingroup numeric_array - */ -class numeric_arrayPubSubType : public eprosima::fastdds::dds::TopicDataType -{ -public: - - typedef numeric_array type; - - eProsima_user_DllExport numeric_arrayPubSubType(); - - eProsima_user_DllExport ~numeric_arrayPubSubType() override; - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload) override - { - return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport bool serialize( - const void* const data, - eprosima::fastdds::rtps::SerializedPayload_t* payload, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool deserialize( - eprosima::fastdds::rtps::SerializedPayload_t* payload, - void* data) override; - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data) override - { - return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); - } - - eProsima_user_DllExport std::function getSerializedSizeProvider( - const void* const data, - eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; - - eProsima_user_DllExport bool getKey( - const void* const data, - eprosima::fastdds::rtps::InstanceHandle_t* ihandle, - bool force_md5 = false) override; - - eProsima_user_DllExport void* createData() override; - - eProsima_user_DllExport void deleteData( - void* data) override; - - //Register TypeObject representation in Fast DDS TypeObjectRegistry - eProsima_user_DllExport void register_type_object_representation() override; - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - eProsima_user_DllExport inline bool is_bounded() const override - { - return true; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED - -#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - eProsima_user_DllExport inline bool is_plain() const override - { - return false; - } - - eProsima_user_DllExport inline bool is_plain( - eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override - { - static_cast(data_representation); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN - -#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - eProsima_user_DllExport inline bool construct_sample( - void* memory) const override - { - static_cast(memory); - return false; - } - -#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE - - eprosima::fastdds::MD5 m_md5; - unsigned char* m_keyBuffer; - -}; - -#endif // FAST_DDS_GENERATED__NUMERIC_ARRAY_PUBSUBTYPES_HPP - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx deleted file mode 100644 index 22b35f279c1..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.cxx +++ /dev/null @@ -1,134 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayTypeObjectSupport.cxx - * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#include "numeric_arrayTypeObjectSupport.hpp" - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "numeric_array.hpp" - - -using namespace eprosima::fastdds::dds::xtypes; - -// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_numeric_array_type_identifier( - TypeIdentifierPair& type_ids_numeric_array) -{ - - ReturnCode_t return_code_numeric_array {eprosima::fastdds::dds::RETCODE_OK}; - return_code_numeric_array = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "numeric_array", type_ids_numeric_array); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_numeric_array) - { - StructTypeFlag struct_flags_numeric_array = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, - false, false); - QualifiedTypeName type_name_numeric_array = "numeric_array"; - eprosima::fastcdr::optional type_ann_builtin_numeric_array; - eprosima::fastcdr::optional ann_custom_numeric_array; - CompleteTypeDetail detail_numeric_array = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_numeric_array, ann_custom_numeric_array, type_name_numeric_array.to_string()); - CompleteStructHeader header_numeric_array; - header_numeric_array = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_numeric_array); - CompleteStructMemberSeq member_seq_numeric_array; - { - TypeIdentifierPair type_ids_points; - ReturnCode_t return_code_points {eprosima::fastdds::dds::RETCODE_OK}; - return_code_points = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "anonymous_array_int32_t_3", type_ids_points); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_points) - { - return_code_points = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_int32_t", type_ids_points); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_points) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "Array element TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - bool element_identifier_anonymous_array_int32_t_3_ec {false}; - TypeIdentifier* element_identifier_anonymous_array_int32_t_3 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_points, element_identifier_anonymous_array_int32_t_3_ec))}; - if (!element_identifier_anonymous_array_int32_t_3_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Array element TypeIdentifier inconsistent."); - return; - } - EquivalenceKind equiv_kind_anonymous_array_int32_t_3 = EK_COMPLETE; - if (TK_NONE == type_ids_points.type_identifier2()._d()) - { - equiv_kind_anonymous_array_int32_t_3 = EK_BOTH; - } - CollectionElementFlag element_flags_anonymous_array_int32_t_3 = 0; - PlainCollectionHeader header_anonymous_array_int32_t_3 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_array_int32_t_3, element_flags_anonymous_array_int32_t_3); - { - SBoundSeq array_bound_seq; - TypeObjectUtils::add_array_dimension(array_bound_seq, static_cast(3)); - - PlainArraySElemDefn array_sdefn = TypeObjectUtils::build_plain_array_s_elem_defn(header_anonymous_array_int32_t_3, array_bound_seq, - eprosima::fastcdr::external(element_identifier_anonymous_array_int32_t_3)); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_s_array_type_identifier(array_sdefn, "anonymous_array_int32_t_3", type_ids_points)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "anonymous_array_int32_t_3 already registered in TypeObjectRegistry for a different type."); - } - } - } - StructMemberFlag member_flags_points = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_points = 0x00000000; - bool common_points_ec {false}; - CommonStructMember common_points {TypeObjectUtils::build_common_struct_member(member_id_points, member_flags_points, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_points, common_points_ec))}; - if (!common_points_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure points member TypeIdentifier inconsistent."); - return; - } - MemberName name_points = "points"; - eprosima::fastcdr::optional member_ann_builtin_points; - ann_custom_numeric_array.reset(); - CompleteMemberDetail detail_points = TypeObjectUtils::build_complete_member_detail(name_points, member_ann_builtin_points, ann_custom_numeric_array); - CompleteStructMember member_points = TypeObjectUtils::build_complete_struct_member(common_points, detail_points); - TypeObjectUtils::add_complete_struct_member(member_seq_numeric_array, member_points); - } - CompleteStructType struct_type_numeric_array = TypeObjectUtils::build_complete_struct_type(struct_flags_numeric_array, header_numeric_array, member_seq_numeric_array); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_numeric_array, type_name_numeric_array.to_string(), type_ids_numeric_array)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "numeric_array already registered in TypeObjectRegistry for a different type."); - } - } -} - diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp deleted file mode 100644 index b6219fd7034..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/numeric_array/numeric_arrayTypeObjectSupport.hpp +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -/*! - * @file numeric_arrayTypeObjectSupport.hpp - * Header file containing the API required to register the TypeObject representation of the described types in the IDL file - * - * This file was generated by the tool fastddsgen. - */ - -#ifndef FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP - -#include - - -#if defined(_WIN32) -#if defined(EPROSIMA_USER_DLL_EXPORT) -#define eProsima_user_DllExport __declspec( dllexport ) -#else -#define eProsima_user_DllExport -#endif // EPROSIMA_USER_DLL_EXPORT -#else -#define eProsima_user_DllExport -#endif // _WIN32 - -#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -/** - * @brief Register numeric_array related TypeIdentifier. - * Fully-descriptive TypeIdentifiers are directly registered. - * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is - * indirectly registered as well. - * - * @param[out] TypeIdentifier of the registered type. - * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. - * Invalid TypeIdentifier is returned in case of error. - */ -eProsima_user_DllExport void register_numeric_array_type_identifier( - eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); - - -#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC - -#endif // FAST_DDS_GENERATED__NUMERIC_ARRAY_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl deleted file mode 100644 index 5d9f9819408..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/arrays_and_sequences.idl +++ /dev/null @@ -1,12 +0,0 @@ -struct AnInternalObject -{ - float x; - boolean positive; -}; - -struct arrays_and_sequences -{ - sequence unlimited_vector; - sequence limited_vector; - AnInternalObject limited_array[10]; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl deleted file mode 100644 index b81e59565ec..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_array_struct.idl +++ /dev/null @@ -1,11 +0,0 @@ -struct TheOtherObjectInArray -{ - long some_num; - boolean positive; -}; - -struct basic_array_struct -{ - unsigned long index; - TheOtherObjectInArray sub_structs[5]; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl deleted file mode 100644 index da2ea1bbe0a..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/basic_struct.idl +++ /dev/null @@ -1,9 +0,0 @@ -struct TheOtherObject -{ - long some_num; -}; - -struct basic_struct -{ - TheOtherObject sub_struct; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl deleted file mode 100644 index 0abf7dd8bb2..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/char_sequence.idl +++ /dev/null @@ -1,4 +0,0 @@ -struct char_sequence -{ - sequence chars; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl deleted file mode 100644 index b4eca21b735..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/complex_nested_arrays.idl +++ /dev/null @@ -1,23 +0,0 @@ -struct ThirdLevelElement -{ - double x; - double y; -}; - -struct SecondLevelElement -{ - ThirdLevelElement an_element_alone; - sequence a_limited_other_value; -}; - -struct FirstLevelElement -{ - string useless_name; - sequence sub; - ThirdLevelElement an_element_alone; -}; - -struct complex_nested_arrays -{ - FirstLevelElement array_of_elements[3]; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl deleted file mode 100644 index c587eba0fd1..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/extensibility_struct.idl +++ /dev/null @@ -1,23 +0,0 @@ -@extensibility(FINAL) -struct FinalStruct -{ - octet color; -}; - -@extensibility(MUTABLE) -struct MutableStruct -{ - octet color; -}; - -struct AppendableStruct -{ - octet color; -}; - -struct extensibility_struct -{ - FinalStruct red; - MutableStruct blue; - AppendableStruct green; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl deleted file mode 100644 index b297df865e0..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/float_bounded_sequence.idl +++ /dev/null @@ -1,4 +0,0 @@ -struct float_bounded_sequence -{ - sequence numbers; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl deleted file mode 100644 index d82036d8963..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/hello_world.idl +++ /dev/null @@ -1,5 +0,0 @@ -struct hello_world -{ - unsigned long index; - string message; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl deleted file mode 100644 index c4a52662b4d..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/inheritance_struct.idl +++ /dev/null @@ -1,29 +0,0 @@ -struct GreatgrandfatherStruct -{ - long greatgrandfather; -}; - -struct GrandfatherStruct : GreatgrandfatherStruct -{ - long grandfather; -}; - -struct FatherStruct : GrandfatherStruct -{ - long father; -}; - -struct SonStruct : FatherStruct -{ - long son; -}; - -struct GrandsonStruct : SonStruct -{ - long grandson; -}; - -struct inheritance_struct : GrandsonStruct -{ - long value; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl deleted file mode 100644 index 7137a0b6872..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/key_struct.idl +++ /dev/null @@ -1,6 +0,0 @@ -struct key_struct -{ - short small_num; - @key long big_num; - @key unsigned long long huge_num; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl deleted file mode 100644 index 3d0561202ce..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_bounded_struct.idl +++ /dev/null @@ -1,4 +0,0 @@ -struct map_bounded_struct -{ - map my_map; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl deleted file mode 100644 index 0cfb2f03bd9..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/multi_array_struct.idl +++ /dev/null @@ -1,11 +0,0 @@ -struct ColorAmount -{ - long red; - long green; - long blue; -}; - -struct multi_array_struct -{ - ColorAmount colors[5][5][5]; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl deleted file mode 100644 index 0d1f5f71f69..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/nested_struct.idl +++ /dev/null @@ -1,33 +0,0 @@ -struct FirstStruct -{ - long value; -}; - -struct SecondStruct -{ - FirstStruct first; -}; - -struct ThirdStruct -{ - SecondStruct second; -}; - -struct FourthStruct -{ - ThirdStruct third; -}; - -struct FifthStruct -{ - FourthStruct fourth; -}; - -struct nested_struct -{ - FirstStruct first; - SecondStruct second; - ThirdStruct third; - FourthStruct fourth; - FifthStruct fifth; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl b/test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl deleted file mode 100644 index 814abd597d6..00000000000 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/numeric_array.idl +++ /dev/null @@ -1,4 +0,0 @@ -struct numeric_array -{ - long points[3]; -}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_struct.hpp new file mode 100644 index 00000000000..0d4526b9a6d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_struct.hpp @@ -0,0 +1,508 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_HPP + +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(KEY_STRUCT_SOURCE) +#define KEY_STRUCT_DllAPI __declspec( dllexport ) +#else +#define KEY_STRUCT_DllAPI __declspec( dllimport ) +#endif // KEY_STRUCT_SOURCE +#else +#define KEY_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define KEY_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure ImportantStruct defined by the user in the IDL file. + * @ingroup key_struct + */ +class ImportantStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ImportantStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ImportantStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ImportantStruct that will be copied. + */ + eProsima_user_DllExport ImportantStruct( + const ImportantStruct& x) + { + m_my_first_value = x.m_my_first_value; + + m_my_second_value = x.m_my_second_value; + + m_my_third_value = x.m_my_third_value; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ImportantStruct that will be copied. + */ + eProsima_user_DllExport ImportantStruct( + ImportantStruct&& x) noexcept + { + m_my_first_value = x.m_my_first_value; + m_my_second_value = x.m_my_second_value; + m_my_third_value = x.m_my_third_value; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ImportantStruct that will be copied. + */ + eProsima_user_DllExport ImportantStruct& operator =( + const ImportantStruct& x) + { + + m_my_first_value = x.m_my_first_value; + + m_my_second_value = x.m_my_second_value; + + m_my_third_value = x.m_my_third_value; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ImportantStruct that will be copied. + */ + eProsima_user_DllExport ImportantStruct& operator =( + ImportantStruct&& x) noexcept + { + + m_my_first_value = x.m_my_first_value; + m_my_second_value = x.m_my_second_value; + m_my_third_value = x.m_my_third_value; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ImportantStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ImportantStruct& x) const + { + return (m_my_first_value == x.m_my_first_value && + m_my_second_value == x.m_my_second_value && + m_my_third_value == x.m_my_third_value); + } + + /*! + * @brief Comparison operator. + * @param x ImportantStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ImportantStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_first_value + * @param _my_first_value New value for member my_first_value + */ + eProsima_user_DllExport void my_first_value( + int32_t _my_first_value) + { + m_my_first_value = _my_first_value; + } + + /*! + * @brief This function returns the value of member my_first_value + * @return Value of member my_first_value + */ + eProsima_user_DllExport int32_t my_first_value() const + { + return m_my_first_value; + } + + /*! + * @brief This function returns a reference to member my_first_value + * @return Reference to member my_first_value + */ + eProsima_user_DllExport int32_t& my_first_value() + { + return m_my_first_value; + } + + + /*! + * @brief This function sets a value in member my_second_value + * @param _my_second_value New value for member my_second_value + */ + eProsima_user_DllExport void my_second_value( + int32_t _my_second_value) + { + m_my_second_value = _my_second_value; + } + + /*! + * @brief This function returns the value of member my_second_value + * @return Value of member my_second_value + */ + eProsima_user_DllExport int32_t my_second_value() const + { + return m_my_second_value; + } + + /*! + * @brief This function returns a reference to member my_second_value + * @return Reference to member my_second_value + */ + eProsima_user_DllExport int32_t& my_second_value() + { + return m_my_second_value; + } + + + /*! + * @brief This function sets a value in member my_third_value + * @param _my_third_value New value for member my_third_value + */ + eProsima_user_DllExport void my_third_value( + int32_t _my_third_value) + { + m_my_third_value = _my_third_value; + } + + /*! + * @brief This function returns the value of member my_third_value + * @return Value of member my_third_value + */ + eProsima_user_DllExport int32_t my_third_value() const + { + return m_my_third_value; + } + + /*! + * @brief This function returns a reference to member my_third_value + * @return Reference to member my_third_value + */ + eProsima_user_DllExport int32_t& my_third_value() + { + return m_my_third_value; + } + + + +private: + + int32_t m_my_first_value{0}; + int32_t m_my_second_value{0}; + int32_t m_my_third_value{0}; + +}; +/*! + * @brief This class represents the structure KeyStruct defined by the user in the IDL file. + * @ingroup key_struct + */ +class KeyStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport KeyStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~KeyStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object KeyStruct that will be copied. + */ + eProsima_user_DllExport KeyStruct( + const KeyStruct& x) + { + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_string = x.m_my_string; + + m_my_important_struct = x.m_my_important_struct; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object KeyStruct that will be copied. + */ + eProsima_user_DllExport KeyStruct( + KeyStruct&& x) noexcept + { + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_string = std::move(x.m_my_string); + m_my_important_struct = std::move(x.m_my_important_struct); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object KeyStruct that will be copied. + */ + eProsima_user_DllExport KeyStruct& operator =( + const KeyStruct& x) + { + + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_string = x.m_my_string; + + m_my_important_struct = x.m_my_important_struct; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object KeyStruct that will be copied. + */ + eProsima_user_DllExport KeyStruct& operator =( + KeyStruct&& x) noexcept + { + + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_string = std::move(x.m_my_string); + m_my_important_struct = std::move(x.m_my_important_struct); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x KeyStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const KeyStruct& x) const + { + return (m_my_short == x.m_my_short && + m_my_long == x.m_my_long && + m_my_string == x.m_my_string && + m_my_important_struct == x.m_my_important_struct); + } + + /*! + * @brief Comparison operator. + * @param x KeyStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const KeyStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short + */ + eProsima_user_DllExport void my_short( + int16_t _my_short) + { + m_my_short = _my_short; + } + + /*! + * @brief This function returns the value of member my_short + * @return Value of member my_short + */ + eProsima_user_DllExport int16_t my_short() const + { + return m_my_short; + } + + /*! + * @brief This function returns a reference to member my_short + * @return Reference to member my_short + */ + eProsima_user_DllExport int16_t& my_short() + { + return m_my_short; + } + + + /*! + * @brief This function sets a value in member my_long + * @param _my_long New value for member my_long + */ + eProsima_user_DllExport void my_long( + int32_t _my_long) + { + m_my_long = _my_long; + } + + /*! + * @brief This function returns the value of member my_long + * @return Value of member my_long + */ + eProsima_user_DllExport int32_t my_long() const + { + return m_my_long; + } + + /*! + * @brief This function returns a reference to member my_long + * @return Reference to member my_long + */ + eProsima_user_DllExport int32_t& my_long() + { + return m_my_long; + } + + + /*! + * @brief This function copies the value in member my_string + * @param _my_string New value to be copied in member my_string + */ + eProsima_user_DllExport void my_string( + const std::string& _my_string) + { + m_my_string = _my_string; + } + + /*! + * @brief This function moves the value in member my_string + * @param _my_string New value to be moved in member my_string + */ + eProsima_user_DllExport void my_string( + std::string&& _my_string) + { + m_my_string = std::move(_my_string); + } + + /*! + * @brief This function returns a constant reference to member my_string + * @return Constant reference to member my_string + */ + eProsima_user_DllExport const std::string& my_string() const + { + return m_my_string; + } + + /*! + * @brief This function returns a reference to member my_string + * @return Reference to member my_string + */ + eProsima_user_DllExport std::string& my_string() + { + return m_my_string; + } + + + /*! + * @brief This function copies the value in member my_important_struct + * @param _my_important_struct New value to be copied in member my_important_struct + */ + eProsima_user_DllExport void my_important_struct( + const ImportantStruct& _my_important_struct) + { + m_my_important_struct = _my_important_struct; + } + + /*! + * @brief This function moves the value in member my_important_struct + * @param _my_important_struct New value to be moved in member my_important_struct + */ + eProsima_user_DllExport void my_important_struct( + ImportantStruct&& _my_important_struct) + { + m_my_important_struct = std::move(_my_important_struct); + } + + /*! + * @brief This function returns a constant reference to member my_important_struct + * @return Constant reference to member my_important_struct + */ + eProsima_user_DllExport const ImportantStruct& my_important_struct() const + { + return m_my_important_struct; + } + + /*! + * @brief This function returns a reference to member my_important_struct + * @return Reference to member my_important_struct + */ + eProsima_user_DllExport ImportantStruct& my_important_struct() + { + return m_my_important_struct; + } + + + +private: + + int16_t m_my_short{0}; + int32_t m_my_long{0}; + std::string m_my_string; + ImportantStruct m_my_important_struct; + +}; + +#endif // _FAST_DDS_GENERATED_KEY_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.hpp similarity index 75% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.hpp index a92fb5c4afb..47a05f2d065 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/key_struct/key_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.hpp @@ -24,8 +24,11 @@ #include "key_struct.hpp" -constexpr uint32_t key_struct_max_cdr_typesize {24UL}; -constexpr uint32_t key_struct_max_key_cdr_typesize {16UL}; +constexpr uint32_t ImportantStruct_max_cdr_typesize {16UL}; +constexpr uint32_t ImportantStruct_max_key_cdr_typesize {8UL}; + +constexpr uint32_t KeyStruct_max_cdr_typesize {288UL}; +constexpr uint32_t KeyStruct_max_key_cdr_typesize {272UL}; namespace eprosima { @@ -36,7 +39,11 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const key_struct& data); + const ImportantStruct& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const KeyStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.ipp similarity index 70% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.ipp index 8a5c223f8c1..d10cdaa4911 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structCdrAux.ipp @@ -13,16 +13,16 @@ // limitations under the License. /*! - * @file arrays_and_sequencesCdrAux.ipp + * @file key_structCdrAux.ipp * This source file contains some declarations of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP -#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP +#ifndef FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP -#include "arrays_and_sequencesCdrAux.hpp" +#include "key_structCdrAux.hpp" #include #include @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const AnInternalObject& data, + const ImportantStruct& data, size_t& current_alignment) { static_cast(data); @@ -51,10 +51,13 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.x(), current_alignment); + data.my_first_value(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.positive(), current_alignment); + data.my_second_value(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_third_value(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -65,7 +68,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const AnInternalObject& data) + const ImportantStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -74,8 +77,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.x() - << eprosima::fastcdr::MemberId(1) << data.positive() + << eprosima::fastcdr::MemberId(0) << data.my_first_value() + << eprosima::fastcdr::MemberId(1) << data.my_second_value() + << eprosima::fastcdr::MemberId(2) << data.my_third_value() ; scdr.end_serialize_type(current_state); } @@ -83,7 +87,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - AnInternalObject& data) + ImportantStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -94,11 +98,15 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.x(); + dcdr >> data.my_first_value(); break; case 1: - dcdr >> data.positive(); + dcdr >> data.my_second_value(); + break; + + case 2: + dcdr >> data.my_third_value(); break; default: @@ -111,17 +119,22 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const AnInternalObject& data) + const ImportantStruct& data) { static_cast(scdr); static_cast(data); + scdr << data.my_first_value(); + + + scdr << data.my_third_value(); + } template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const arrays_and_sequences& data, + const KeyStruct& data, size_t& current_alignment) { static_cast(data); @@ -135,13 +148,16 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.unlimited_vector(), current_alignment); + data.my_short(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.limited_vector(), current_alignment); + data.my_long(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.limited_array(), current_alignment); + data.my_string(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_important_struct(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -152,7 +168,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const arrays_and_sequences& data) + const KeyStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -161,9 +177,10 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.unlimited_vector() - << eprosima::fastcdr::MemberId(1) << data.limited_vector() - << eprosima::fastcdr::MemberId(2) << data.limited_array() + << eprosima::fastcdr::MemberId(0) << data.my_short() + << eprosima::fastcdr::MemberId(1) << data.my_long() + << eprosima::fastcdr::MemberId(2) << data.my_string() + << eprosima::fastcdr::MemberId(3) << data.my_important_struct() ; scdr.end_serialize_type(current_state); } @@ -171,7 +188,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - arrays_and_sequences& data) + KeyStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -182,15 +199,19 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.unlimited_vector(); + dcdr >> data.my_short(); break; case 1: - dcdr >> data.limited_vector(); + dcdr >> data.my_long(); break; case 2: - dcdr >> data.limited_array(); + dcdr >> data.my_string(); + break; + + case 3: + dcdr >> data.my_important_struct(); break; default: @@ -203,10 +224,16 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const arrays_and_sequences& data) + const KeyStruct& data) { static_cast(scdr); static_cast(data); + scdr << data.my_long(); + + scdr << data.my_string(); + + serialize_key(scdr, data.my_important_struct()); + } @@ -214,5 +241,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_IPP +#endif // FAST_DDS_GENERATED__KEY_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.cxx similarity index 79% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.cxx index e42464daefa..4a48941b222 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.cxx @@ -13,42 +13,42 @@ // limitations under the License. /*! - * @file basic_structPubSubTypes.cpp + * @file key_structPubSubTypes.cpp * This header file contains the implementation of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#include "basic_structPubSubTypes.hpp" +#include "key_structPubSubTypes.hpp" #include #include -#include "basic_structCdrAux.hpp" -#include "basic_structTypeObjectSupport.hpp" +#include "key_structCdrAux.hpp" +#include "key_structTypeObjectSupport.hpp" using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -TheOtherObjectPubSubType::TheOtherObjectPubSubType() +ImportantStructPubSubType::ImportantStructPubSubType() { - setName("TheOtherObject"); + setName("ImportantStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(TheOtherObject::getMaxCdrSerializedSize()); + static_cast(ImportantStruct::getMaxCdrSerializedSize()); #else - TheOtherObject_max_cdr_typesize; + ImportantStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = TheOtherObject_max_key_cdr_typesize > 16 ? TheOtherObject_max_key_cdr_typesize : 16; + m_isGetKeyDefined = true; + uint32_t keyLength = ImportantStruct_max_key_cdr_typesize > 16 ? ImportantStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -TheOtherObjectPubSubType::~TheOtherObjectPubSubType() +ImportantStructPubSubType::~ImportantStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ TheOtherObjectPubSubType::~TheOtherObjectPubSubType() } } -bool TheOtherObjectPubSubType::serialize( +bool ImportantStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const TheOtherObject* p_type = static_cast(data); + const ImportantStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool TheOtherObjectPubSubType::serialize( return true; } -bool TheOtherObjectPubSubType::deserialize( +bool ImportantStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - TheOtherObject* p_type = static_cast(data); + ImportantStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool TheOtherObjectPubSubType::deserialize( return true; } -std::function TheOtherObjectPubSubType::getSerializedSizeProvider( +std::function ImportantStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function TheOtherObjectPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function TheOtherObjectPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function TheOtherObjectPubSubType::getSerializedSizeProvider( }; } -void* TheOtherObjectPubSubType::createData() +void* ImportantStructPubSubType::createData() { - return reinterpret_cast(new TheOtherObject()); + return reinterpret_cast(new ImportantStruct()); } -void TheOtherObjectPubSubType::deleteData( +void ImportantStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool TheOtherObjectPubSubType::getKey( +bool ImportantStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool TheOtherObjectPubSubType::getKey( return false; } - const TheOtherObject* p_type = static_cast(data); + const ImportantStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - TheOtherObject_max_key_cdr_typesize); + ImportantStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool TheOtherObjectPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || TheOtherObject_max_key_cdr_typesize > 16) + if (force_md5 || ImportantStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,29 +219,29 @@ bool TheOtherObjectPubSubType::getKey( return true; } -void TheOtherObjectPubSubType::register_type_object_representation() +void ImportantStructPubSubType::register_type_object_representation() { - register_TheOtherObject_type_identifier(type_identifiers_); + register_ImportantStruct_type_identifier(type_identifiers_); } -basic_structPubSubType::basic_structPubSubType() +KeyStructPubSubType::KeyStructPubSubType() { - setName("basic_struct"); + setName("KeyStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(basic_struct::getMaxCdrSerializedSize()); + static_cast(KeyStruct::getMaxCdrSerializedSize()); #else - basic_struct_max_cdr_typesize; + KeyStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ - m_isGetKeyDefined = false; - uint32_t keyLength = basic_struct_max_key_cdr_typesize > 16 ? basic_struct_max_key_cdr_typesize : 16; + m_isGetKeyDefined = true; + uint32_t keyLength = KeyStruct_max_key_cdr_typesize > 16 ? KeyStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -basic_structPubSubType::~basic_structPubSubType() +KeyStructPubSubType::~KeyStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -249,12 +249,12 @@ basic_structPubSubType::~basic_structPubSubType() } } -bool basic_structPubSubType::serialize( +bool KeyStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const basic_struct* p_type = static_cast(data); + const KeyStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -291,14 +291,14 @@ bool basic_structPubSubType::serialize( return true; } -bool basic_structPubSubType::deserialize( +bool KeyStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - basic_struct* p_type = static_cast(data); + KeyStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -325,7 +325,7 @@ bool basic_structPubSubType::deserialize( return true; } -std::function basic_structPubSubType::getSerializedSizeProvider( +std::function KeyStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -333,7 +333,7 @@ std::function basic_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -343,7 +343,7 @@ std::function basic_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -354,18 +354,18 @@ std::function basic_structPubSubType::getSerializedSizeProvider( }; } -void* basic_structPubSubType::createData() +void* KeyStructPubSubType::createData() { - return reinterpret_cast(new basic_struct()); + return reinterpret_cast(new KeyStruct()); } -void basic_structPubSubType::deleteData( +void KeyStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool basic_structPubSubType::getKey( +bool KeyStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -375,11 +375,11 @@ bool basic_structPubSubType::getKey( return false; } - const basic_struct* p_type = static_cast(data); + const KeyStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - basic_struct_max_key_cdr_typesize); + KeyStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -388,7 +388,7 @@ bool basic_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || basic_struct_max_key_cdr_typesize > 16) + if (force_md5 || KeyStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -412,11 +412,11 @@ bool basic_structPubSubType::getKey( return true; } -void basic_structPubSubType::register_type_object_representation() +void KeyStructPubSubType::register_type_object_representation() { - register_basic_struct_type_identifier(type_identifiers_); + register_KeyStruct_type_identifier(type_identifiers_); } // Include auxiliary functions like for serializing/deserializing. -#include "basic_structCdrAux.ipp" +#include "key_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.hpp index 29824879bb8..bb3d4678554 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structPubSubTypes.hpp @@ -13,15 +13,15 @@ // limitations under the License. /*! - * @file basic_structPubSubTypes.hpp + * @file key_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP #include #include @@ -29,28 +29,28 @@ #include #include -#include "basic_struct.hpp" +#include "key_struct.hpp" #if !defined(GEN_API_VER) || (GEN_API_VER != 2) #error \ - Generated basic_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. + Generated key_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // GEN_API_VER /*! - * @brief This class represents the TopicDataType of the type TheOtherObject defined by the user in the IDL file. - * @ingroup basic_struct + * @brief This class represents the TopicDataType of the type ImportantStruct defined by the user in the IDL file. + * @ingroup key_struct */ -class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType +class ImportantStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef TheOtherObject type; + typedef ImportantStruct type; - eProsima_user_DllExport TheOtherObjectPubSubType(); + eProsima_user_DllExport ImportantStructPubSubType(); - eProsima_user_DllExport ~TheOtherObjectPubSubType() override; + eProsima_user_DllExport ~ImportantStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -130,18 +130,18 @@ class TheOtherObjectPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type basic_struct defined by the user in the IDL file. - * @ingroup basic_struct + * @brief This class represents the TopicDataType of the type KeyStruct defined by the user in the IDL file. + * @ingroup key_struct */ -class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class KeyStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef basic_struct type; + typedef KeyStruct type; - eProsima_user_DllExport basic_structPubSubType(); + eProsima_user_DllExport KeyStructPubSubType(); - eProsima_user_DllExport ~basic_structPubSubType() override; + eProsima_user_DllExport ~KeyStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -185,7 +185,7 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -220,5 +220,5 @@ class basic_structPubSubType : public eprosima::fastdds::dds::TopicDataType }; -#endif // FAST_DDS_GENERATED__BASIC_STRUCT_PUBSUBTYPES_HPP +#endif // FAST_DDS_GENERATED__KEY_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..8b72a3d175c --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.cxx @@ -0,0 +1,380 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file key_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "key_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "key_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ImportantStruct_type_identifier( + TypeIdentifierPair& type_ids_ImportantStruct) +{ + + ReturnCode_t return_code_ImportantStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ImportantStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ImportantStruct", type_ids_ImportantStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ImportantStruct) + { + StructTypeFlag struct_flags_ImportantStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ImportantStruct = "ImportantStruct"; + eprosima::fastcdr::optional type_ann_builtin_ImportantStruct; + eprosima::fastcdr::optional ann_custom_ImportantStruct; + CompleteTypeDetail detail_ImportantStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ImportantStruct, ann_custom_ImportantStruct, type_name_ImportantStruct.to_string()); + CompleteStructHeader header_ImportantStruct; + header_ImportantStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ImportantStruct); + CompleteStructMemberSeq member_seq_ImportantStruct; + { + TypeIdentifierPair type_ids_my_first_value; + ReturnCode_t return_code_my_first_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_first_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_first_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_first_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_first_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_first_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_my_first_value = 0x00000000; + bool common_my_first_value_ec {false}; + CommonStructMember common_my_first_value {TypeObjectUtils::build_common_struct_member(member_id_my_first_value, member_flags_my_first_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_first_value, common_my_first_value_ec))}; + if (!common_my_first_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_first_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_first_value = "my_first_value"; + eprosima::fastcdr::optional member_ann_builtin_my_first_value; + ann_custom_ImportantStruct.reset(); + AppliedAnnotationSeq tmp_ann_custom_my_first_value; + eprosima::fastcdr::optional unit_my_first_value; + eprosima::fastcdr::optional min_my_first_value; + eprosima::fastcdr::optional max_my_first_value; + eprosima::fastcdr::optional hash_id_my_first_value; + if (unit_my_first_value.has_value() || min_my_first_value.has_value() || max_my_first_value.has_value() || hash_id_my_first_value.has_value()) + { + member_ann_builtin_my_first_value = TypeObjectUtils::build_applied_builtin_member_annotations(unit_my_first_value, min_my_first_value, max_my_first_value, hash_id_my_first_value); + } + if (!tmp_ann_custom_my_first_value.empty()) + { + ann_custom_ImportantStruct = tmp_ann_custom_my_first_value; + } + CompleteMemberDetail detail_my_first_value = TypeObjectUtils::build_complete_member_detail(name_my_first_value, member_ann_builtin_my_first_value, ann_custom_ImportantStruct); + CompleteStructMember member_my_first_value = TypeObjectUtils::build_complete_struct_member(common_my_first_value, detail_my_first_value); + TypeObjectUtils::add_complete_struct_member(member_seq_ImportantStruct, member_my_first_value); + } + { + TypeIdentifierPair type_ids_my_second_value; + ReturnCode_t return_code_my_second_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_second_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_second_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_second_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_second_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_second_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_second_value = 0x00000001; + bool common_my_second_value_ec {false}; + CommonStructMember common_my_second_value {TypeObjectUtils::build_common_struct_member(member_id_my_second_value, member_flags_my_second_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_second_value, common_my_second_value_ec))}; + if (!common_my_second_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_second_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_second_value = "my_second_value"; + eprosima::fastcdr::optional member_ann_builtin_my_second_value; + ann_custom_ImportantStruct.reset(); + CompleteMemberDetail detail_my_second_value = TypeObjectUtils::build_complete_member_detail(name_my_second_value, member_ann_builtin_my_second_value, ann_custom_ImportantStruct); + CompleteStructMember member_my_second_value = TypeObjectUtils::build_complete_struct_member(common_my_second_value, detail_my_second_value); + TypeObjectUtils::add_complete_struct_member(member_seq_ImportantStruct, member_my_second_value); + } + { + TypeIdentifierPair type_ids_my_third_value; + ReturnCode_t return_code_my_third_value {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_third_value = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_third_value); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_third_value) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_third_value Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_third_value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_my_third_value = 0x00000002; + bool common_my_third_value_ec {false}; + CommonStructMember common_my_third_value {TypeObjectUtils::build_common_struct_member(member_id_my_third_value, member_flags_my_third_value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_third_value, common_my_third_value_ec))}; + if (!common_my_third_value_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_third_value member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_third_value = "my_third_value"; + eprosima::fastcdr::optional member_ann_builtin_my_third_value; + ann_custom_ImportantStruct.reset(); + AppliedAnnotationSeq tmp_ann_custom_my_third_value; + eprosima::fastcdr::optional unit_my_third_value; + eprosima::fastcdr::optional min_my_third_value; + eprosima::fastcdr::optional max_my_third_value; + eprosima::fastcdr::optional hash_id_my_third_value; + if (unit_my_third_value.has_value() || min_my_third_value.has_value() || max_my_third_value.has_value() || hash_id_my_third_value.has_value()) + { + member_ann_builtin_my_third_value = TypeObjectUtils::build_applied_builtin_member_annotations(unit_my_third_value, min_my_third_value, max_my_third_value, hash_id_my_third_value); + } + if (!tmp_ann_custom_my_third_value.empty()) + { + ann_custom_ImportantStruct = tmp_ann_custom_my_third_value; + } + CompleteMemberDetail detail_my_third_value = TypeObjectUtils::build_complete_member_detail(name_my_third_value, member_ann_builtin_my_third_value, ann_custom_ImportantStruct); + CompleteStructMember member_my_third_value = TypeObjectUtils::build_complete_struct_member(common_my_third_value, detail_my_third_value); + TypeObjectUtils::add_complete_struct_member(member_seq_ImportantStruct, member_my_third_value); + } + CompleteStructType struct_type_ImportantStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ImportantStruct, header_ImportantStruct, member_seq_ImportantStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ImportantStruct, type_name_ImportantStruct.to_string(), type_ids_ImportantStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ImportantStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_KeyStruct_type_identifier( + TypeIdentifierPair& type_ids_KeyStruct) +{ + + ReturnCode_t return_code_KeyStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_KeyStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "KeyStruct", type_ids_KeyStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_KeyStruct) + { + StructTypeFlag struct_flags_KeyStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_KeyStruct = "KeyStruct"; + eprosima::fastcdr::optional type_ann_builtin_KeyStruct; + eprosima::fastcdr::optional ann_custom_KeyStruct; + CompleteTypeDetail detail_KeyStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_KeyStruct, ann_custom_KeyStruct, type_name_KeyStruct.to_string()); + CompleteStructHeader header_KeyStruct; + header_KeyStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_KeyStruct); + CompleteStructMemberSeq member_seq_KeyStruct; + { + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_my_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_short Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_short = 0x00000000; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; + ann_custom_KeyStruct.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_KeyStruct); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_KeyStruct, member_my_short); + } + { + TypeIdentifierPair type_ids_my_long; + ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_long = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_long); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_long) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_long Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_my_long = 0x00000001; + bool common_my_long_ec {false}; + CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; + if (!common_my_long_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_long member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_long = "my_long"; + eprosima::fastcdr::optional member_ann_builtin_my_long; + ann_custom_KeyStruct.reset(); + AppliedAnnotationSeq tmp_ann_custom_my_long; + eprosima::fastcdr::optional unit_my_long; + eprosima::fastcdr::optional min_my_long; + eprosima::fastcdr::optional max_my_long; + eprosima::fastcdr::optional hash_id_my_long; + if (unit_my_long.has_value() || min_my_long.has_value() || max_my_long.has_value() || hash_id_my_long.has_value()) + { + member_ann_builtin_my_long = TypeObjectUtils::build_applied_builtin_member_annotations(unit_my_long, min_my_long, max_my_long, hash_id_my_long); + } + if (!tmp_ann_custom_my_long.empty()) + { + ann_custom_KeyStruct = tmp_ann_custom_my_long; + } + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_KeyStruct); + CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_KeyStruct, member_my_long); + } + { + TypeIdentifierPair type_ids_my_string; + ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_string) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_my_string = 0x00000002; + bool common_my_string_ec {false}; + CommonStructMember common_my_string {TypeObjectUtils::build_common_struct_member(member_id_my_string, member_flags_my_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_string, common_my_string_ec))}; + if (!common_my_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_string = "my_string"; + eprosima::fastcdr::optional member_ann_builtin_my_string; + ann_custom_KeyStruct.reset(); + AppliedAnnotationSeq tmp_ann_custom_my_string; + eprosima::fastcdr::optional unit_my_string; + eprosima::fastcdr::optional min_my_string; + eprosima::fastcdr::optional max_my_string; + eprosima::fastcdr::optional hash_id_my_string; + if (unit_my_string.has_value() || min_my_string.has_value() || max_my_string.has_value() || hash_id_my_string.has_value()) + { + member_ann_builtin_my_string = TypeObjectUtils::build_applied_builtin_member_annotations(unit_my_string, min_my_string, max_my_string, hash_id_my_string); + } + if (!tmp_ann_custom_my_string.empty()) + { + ann_custom_KeyStruct = tmp_ann_custom_my_string; + } + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_KeyStruct); + CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_KeyStruct, member_my_string); + } + { + TypeIdentifierPair type_ids_my_important_struct; + ReturnCode_t return_code_my_important_struct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_important_struct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ImportantStruct", type_ids_my_important_struct); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_important_struct) + { + ::register_ImportantStruct_type_identifier(type_ids_my_important_struct); + } + StructMemberFlag member_flags_my_important_struct = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, true, false); + MemberId member_id_my_important_struct = 0x00000003; + bool common_my_important_struct_ec {false}; + CommonStructMember common_my_important_struct {TypeObjectUtils::build_common_struct_member(member_id_my_important_struct, member_flags_my_important_struct, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_important_struct, common_my_important_struct_ec))}; + if (!common_my_important_struct_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_important_struct member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_important_struct = "my_important_struct"; + eprosima::fastcdr::optional member_ann_builtin_my_important_struct; + ann_custom_KeyStruct.reset(); + AppliedAnnotationSeq tmp_ann_custom_my_important_struct; + eprosima::fastcdr::optional unit_my_important_struct; + eprosima::fastcdr::optional min_my_important_struct; + eprosima::fastcdr::optional max_my_important_struct; + eprosima::fastcdr::optional hash_id_my_important_struct; + if (unit_my_important_struct.has_value() || min_my_important_struct.has_value() || max_my_important_struct.has_value() || hash_id_my_important_struct.has_value()) + { + member_ann_builtin_my_important_struct = TypeObjectUtils::build_applied_builtin_member_annotations(unit_my_important_struct, min_my_important_struct, max_my_important_struct, hash_id_my_important_struct); + } + if (!tmp_ann_custom_my_important_struct.empty()) + { + ann_custom_KeyStruct = tmp_ann_custom_my_important_struct; + } + CompleteMemberDetail detail_my_important_struct = TypeObjectUtils::build_complete_member_detail(name_my_important_struct, member_ann_builtin_my_important_struct, ann_custom_KeyStruct); + CompleteStructMember member_my_important_struct = TypeObjectUtils::build_complete_struct_member(common_my_important_struct, detail_my_important_struct); + TypeObjectUtils::add_complete_struct_member(member_seq_KeyStruct, member_my_important_struct); + } + CompleteStructType struct_type_KeyStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_KeyStruct, header_KeyStruct, member_seq_KeyStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_KeyStruct, type_name_KeyStruct.to_string(), type_ids_KeyStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "KeyStruct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.hpp similarity index 82% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.hpp index d2cc9a7407e..4c201bb072c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_struct/basic_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/gen/key_structTypeObjectSupport.hpp @@ -13,14 +13,14 @@ // limitations under the License. /*! - * @file basic_structTypeObjectSupport.hpp + * @file key_structTypeObjectSupport.hpp * Header file containing the API required to register the TypeObject representation of the described types in the IDL file * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#ifndef FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register TheOtherObject related TypeIdentifier. + * @brief Register ImportantStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,10 +47,10 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_TheOtherObject_type_identifier( +eProsima_user_DllExport void register_ImportantStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register basic_struct related TypeIdentifier. + * @brief Register KeyStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,10 +59,10 @@ eProsima_user_DllExport void register_TheOtherObject_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_basic_struct_type_identifier( +eProsima_user_DllExport void register_KeyStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // FAST_DDS_GENERATED__BASIC_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#endif // FAST_DDS_GENERATED__KEY_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl new file mode 100644 index 00000000000..b2ce10062f4 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl @@ -0,0 +1,14 @@ +struct ImportantStruct +{ + @key long my_first_value; + long my_second_value; + @key long my_third_value; +}; + +struct KeyStruct +{ + short my_short; + @key long my_long; + @key string my_string; + @key ImportantStruct my_important_struct; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_struct.hpp similarity index 63% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_struct.hpp index 4336aaa055f..7481625166a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_struct.hpp @@ -176,96 +176,110 @@ class ValueStruct }; /*! - * @brief This class represents the structure map_struct defined by the user in the IDL file. + * @brief This class represents the structure MapStruct defined by the user in the IDL file. * @ingroup map_struct */ -class map_struct +class MapStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport map_struct() + eProsima_user_DllExport MapStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~map_struct() + eProsima_user_DllExport ~MapStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object map_struct that will be copied. + * @param x Reference to the object MapStruct that will be copied. */ - eProsima_user_DllExport map_struct( - const map_struct& x) + eProsima_user_DllExport MapStruct( + const MapStruct& x) { m_my_basic_map = x.m_my_basic_map; m_my_complex_map = x.m_my_complex_map; + m_my_basic_bounded_map = x.m_my_basic_bounded_map; + + m_my_complex_bounded_map = x.m_my_complex_bounded_map; + } /*! * @brief Move constructor. - * @param x Reference to the object map_struct that will be copied. + * @param x Reference to the object MapStruct that will be copied. */ - eProsima_user_DllExport map_struct( - map_struct&& x) noexcept + eProsima_user_DllExport MapStruct( + MapStruct&& x) noexcept { m_my_basic_map = std::move(x.m_my_basic_map); m_my_complex_map = std::move(x.m_my_complex_map); + m_my_basic_bounded_map = std::move(x.m_my_basic_bounded_map); + m_my_complex_bounded_map = std::move(x.m_my_complex_bounded_map); } /*! * @brief Copy assignment. - * @param x Reference to the object map_struct that will be copied. + * @param x Reference to the object MapStruct that will be copied. */ - eProsima_user_DllExport map_struct& operator =( - const map_struct& x) + eProsima_user_DllExport MapStruct& operator =( + const MapStruct& x) { m_my_basic_map = x.m_my_basic_map; m_my_complex_map = x.m_my_complex_map; + m_my_basic_bounded_map = x.m_my_basic_bounded_map; + + m_my_complex_bounded_map = x.m_my_complex_bounded_map; + return *this; } /*! * @brief Move assignment. - * @param x Reference to the object map_struct that will be copied. + * @param x Reference to the object MapStruct that will be copied. */ - eProsima_user_DllExport map_struct& operator =( - map_struct&& x) noexcept + eProsima_user_DllExport MapStruct& operator =( + MapStruct&& x) noexcept { m_my_basic_map = std::move(x.m_my_basic_map); m_my_complex_map = std::move(x.m_my_complex_map); + m_my_basic_bounded_map = std::move(x.m_my_basic_bounded_map); + m_my_complex_bounded_map = std::move(x.m_my_complex_bounded_map); return *this; } /*! * @brief Comparison operator. - * @param x map_struct object to compare. + * @param x MapStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const map_struct& x) const + const MapStruct& x) const { return (m_my_basic_map == x.m_my_basic_map && - m_my_complex_map == x.m_my_complex_map); + m_my_complex_map == x.m_my_complex_map && + m_my_basic_bounded_map == x.m_my_basic_bounded_map && + m_my_complex_bounded_map == x.m_my_complex_bounded_map); } /*! * @brief Comparison operator. - * @param x map_struct object to compare. + * @param x MapStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const map_struct& x) const + const MapStruct& x) const { return !(*this == x); } @@ -348,11 +362,91 @@ class map_struct } + /*! + * @brief This function copies the value in member my_basic_bounded_map + * @param _my_basic_bounded_map New value to be copied in member my_basic_bounded_map + */ + eProsima_user_DllExport void my_basic_bounded_map( + const std::map& _my_basic_bounded_map) + { + m_my_basic_bounded_map = _my_basic_bounded_map; + } + + /*! + * @brief This function moves the value in member my_basic_bounded_map + * @param _my_basic_bounded_map New value to be moved in member my_basic_bounded_map + */ + eProsima_user_DllExport void my_basic_bounded_map( + std::map&& _my_basic_bounded_map) + { + m_my_basic_bounded_map = std::move(_my_basic_bounded_map); + } + + /*! + * @brief This function returns a constant reference to member my_basic_bounded_map + * @return Constant reference to member my_basic_bounded_map + */ + eProsima_user_DllExport const std::map& my_basic_bounded_map() const + { + return m_my_basic_bounded_map; + } + + /*! + * @brief This function returns a reference to member my_basic_bounded_map + * @return Reference to member my_basic_bounded_map + */ + eProsima_user_DllExport std::map& my_basic_bounded_map() + { + return m_my_basic_bounded_map; + } + + + /*! + * @brief This function copies the value in member my_complex_bounded_map + * @param _my_complex_bounded_map New value to be copied in member my_complex_bounded_map + */ + eProsima_user_DllExport void my_complex_bounded_map( + const std::map& _my_complex_bounded_map) + { + m_my_complex_bounded_map = _my_complex_bounded_map; + } + + /*! + * @brief This function moves the value in member my_complex_bounded_map + * @param _my_complex_bounded_map New value to be moved in member my_complex_bounded_map + */ + eProsima_user_DllExport void my_complex_bounded_map( + std::map&& _my_complex_bounded_map) + { + m_my_complex_bounded_map = std::move(_my_complex_bounded_map); + } + + /*! + * @brief This function returns a constant reference to member my_complex_bounded_map + * @return Constant reference to member my_complex_bounded_map + */ + eProsima_user_DllExport const std::map& my_complex_bounded_map() const + { + return m_my_complex_bounded_map; + } + + /*! + * @brief This function returns a reference to member my_complex_bounded_map + * @return Reference to member my_complex_bounded_map + */ + eProsima_user_DllExport std::map& my_complex_bounded_map() + { + return m_my_complex_bounded_map; + } + + private: std::map m_my_basic_map; std::map m_my_complex_map; + std::map m_my_basic_bounded_map; + std::map m_my_complex_bounded_map; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.hpp similarity index 90% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.hpp index 120daa8a2df..4a3c9711ef9 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.hpp @@ -24,12 +24,12 @@ #include "map_struct.hpp" -constexpr uint32_t map_struct_max_cdr_typesize {16UL}; -constexpr uint32_t map_struct_max_key_cdr_typesize {0UL}; - constexpr uint32_t ValueStruct_max_cdr_typesize {5UL}; constexpr uint32_t ValueStruct_max_key_cdr_typesize {0UL}; +constexpr uint32_t MapStruct_max_cdr_typesize {3657UL}; +constexpr uint32_t MapStruct_max_key_cdr_typesize {0UL}; + namespace eprosima { namespace fastcdr { @@ -43,7 +43,7 @@ eProsima_user_DllExport void serialize_key( eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const map_struct& data); + const MapStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.ipp similarity index 87% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.ipp index 4df3302bc02..3ae14997cf2 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structCdrAux.ipp @@ -113,7 +113,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const map_struct& data, + const MapStruct& data, size_t& current_alignment) { static_cast(data); @@ -132,6 +132,12 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.my_complex_map(), current_alignment); + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_basic_bounded_map(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_complex_bounded_map(), current_alignment); + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -141,7 +147,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const map_struct& data) + const MapStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -152,6 +158,8 @@ eProsima_user_DllExport void serialize( scdr << eprosima::fastcdr::MemberId(0) << data.my_basic_map() << eprosima::fastcdr::MemberId(1) << data.my_complex_map() + << eprosima::fastcdr::MemberId(2) << data.my_basic_bounded_map() + << eprosima::fastcdr::MemberId(3) << data.my_complex_bounded_map() ; scdr.end_serialize_type(current_state); } @@ -159,7 +167,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - map_struct& data) + MapStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -177,6 +185,14 @@ eProsima_user_DllExport void deserialize( dcdr >> data.my_complex_map(); break; + case 2: + dcdr >> data.my_basic_bounded_map(); + break; + + case 3: + dcdr >> data.my_complex_bounded_map(); + break; + default: ret_value = false; break; @@ -187,7 +203,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const map_struct& data) + const MapStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.cxx similarity index 91% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.cxx index d82e97d64f7..8c30463bdcc 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.cxx @@ -224,24 +224,24 @@ void ValueStructPubSubType::register_type_object_representation() register_ValueStruct_type_identifier(type_identifiers_); } -map_structPubSubType::map_structPubSubType() +MapStructPubSubType::MapStructPubSubType() { - setName("map_struct"); + setName("MapStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(map_struct::getMaxCdrSerializedSize()); + static_cast(MapStruct::getMaxCdrSerializedSize()); #else - map_struct_max_cdr_typesize; + MapStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = map_struct_max_key_cdr_typesize > 16 ? map_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = MapStruct_max_key_cdr_typesize > 16 ? MapStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -map_structPubSubType::~map_structPubSubType() +MapStructPubSubType::~MapStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -249,12 +249,12 @@ map_structPubSubType::~map_structPubSubType() } } -bool map_structPubSubType::serialize( +bool MapStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const map_struct* p_type = static_cast(data); + const MapStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -291,14 +291,14 @@ bool map_structPubSubType::serialize( return true; } -bool map_structPubSubType::deserialize( +bool MapStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - map_struct* p_type = static_cast(data); + MapStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -325,7 +325,7 @@ bool map_structPubSubType::deserialize( return true; } -std::function map_structPubSubType::getSerializedSizeProvider( +std::function MapStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -333,7 +333,7 @@ std::function map_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -343,7 +343,7 @@ std::function map_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -354,18 +354,18 @@ std::function map_structPubSubType::getSerializedSizeProvider( }; } -void* map_structPubSubType::createData() +void* MapStructPubSubType::createData() { - return reinterpret_cast(new map_struct()); + return reinterpret_cast(new MapStruct()); } -void map_structPubSubType::deleteData( +void MapStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool map_structPubSubType::getKey( +bool MapStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -375,11 +375,11 @@ bool map_structPubSubType::getKey( return false; } - const map_struct* p_type = static_cast(data); + const MapStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - map_struct_max_key_cdr_typesize); + MapStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -388,7 +388,7 @@ bool map_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || map_struct_max_key_cdr_typesize > 16) + if (force_md5 || MapStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -412,9 +412,9 @@ bool map_structPubSubType::getKey( return true; } -void map_structPubSubType::register_type_object_representation() +void MapStructPubSubType::register_type_object_representation() { - register_map_struct_type_identifier(type_identifiers_); + register_MapStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.hpp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.hpp index dce42dd8fd2..6cffc72f9e0 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structPubSubTypes.hpp @@ -130,18 +130,18 @@ class ValueStructPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type map_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type MapStruct defined by the user in the IDL file. * @ingroup map_struct */ -class map_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class MapStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef map_struct type; + typedef MapStruct type; - eProsima_user_DllExport map_structPubSubType(); + eProsima_user_DllExport MapStructPubSubType(); - eProsima_user_DllExport ~map_structPubSubType() override; + eProsima_user_DllExport ~MapStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.cxx similarity index 56% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.cxx index 7fee45dd119..eb7eab79b7c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.cxx @@ -98,25 +98,25 @@ void register_ValueStruct_type_identifier( } } // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_map_struct_type_identifier( - TypeIdentifierPair& type_ids_map_struct) +void register_MapStruct_type_identifier( + TypeIdentifierPair& type_ids_MapStruct) { - ReturnCode_t return_code_map_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_map_struct = + ReturnCode_t return_code_MapStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MapStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "map_struct", type_ids_map_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_map_struct) + "MapStruct", type_ids_MapStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MapStruct) { - StructTypeFlag struct_flags_map_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_MapStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_map_struct = "map_struct"; - eprosima::fastcdr::optional type_ann_builtin_map_struct; - eprosima::fastcdr::optional ann_custom_map_struct; - CompleteTypeDetail detail_map_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_map_struct, ann_custom_map_struct, type_name_map_struct.to_string()); - CompleteStructHeader header_map_struct; - header_map_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_map_struct); - CompleteStructMemberSeq member_seq_map_struct; + QualifiedTypeName type_name_MapStruct = "MapStruct"; + eprosima::fastcdr::optional type_ann_builtin_MapStruct; + eprosima::fastcdr::optional ann_custom_MapStruct; + CompleteTypeDetail detail_MapStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MapStruct, ann_custom_MapStruct, type_name_MapStruct.to_string()); + CompleteStructHeader header_MapStruct; + header_MapStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_MapStruct); + CompleteStructMemberSeq member_seq_MapStruct; { TypeIdentifierPair type_ids_my_basic_map; ReturnCode_t return_code_my_basic_map {eprosima::fastdds::dds::RETCODE_OK}; @@ -209,10 +209,10 @@ void register_map_struct_type_identifier( } MemberName name_my_basic_map = "my_basic_map"; eprosima::fastcdr::optional member_ann_builtin_my_basic_map; - ann_custom_map_struct.reset(); - CompleteMemberDetail detail_my_basic_map = TypeObjectUtils::build_complete_member_detail(name_my_basic_map, member_ann_builtin_my_basic_map, ann_custom_map_struct); + ann_custom_MapStruct.reset(); + CompleteMemberDetail detail_my_basic_map = TypeObjectUtils::build_complete_member_detail(name_my_basic_map, member_ann_builtin_my_basic_map, ann_custom_MapStruct); CompleteStructMember member_my_basic_map = TypeObjectUtils::build_complete_struct_member(common_my_basic_map, detail_my_basic_map); - TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_basic_map); + TypeObjectUtils::add_complete_struct_member(member_seq_MapStruct, member_my_basic_map); } { TypeIdentifierPair type_ids_my_complex_map; @@ -304,17 +304,201 @@ void register_map_struct_type_identifier( } MemberName name_my_complex_map = "my_complex_map"; eprosima::fastcdr::optional member_ann_builtin_my_complex_map; - ann_custom_map_struct.reset(); - CompleteMemberDetail detail_my_complex_map = TypeObjectUtils::build_complete_member_detail(name_my_complex_map, member_ann_builtin_my_complex_map, ann_custom_map_struct); + ann_custom_MapStruct.reset(); + CompleteMemberDetail detail_my_complex_map = TypeObjectUtils::build_complete_member_detail(name_my_complex_map, member_ann_builtin_my_complex_map, ann_custom_MapStruct); CompleteStructMember member_my_complex_map = TypeObjectUtils::build_complete_struct_member(common_my_complex_map, detail_my_complex_map); - TypeObjectUtils::add_complete_struct_member(member_seq_map_struct, member_my_complex_map); + TypeObjectUtils::add_complete_struct_member(member_seq_MapStruct, member_my_complex_map); } - CompleteStructType struct_type_map_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_map_struct, header_map_struct, member_seq_map_struct); + { + TypeIdentifierPair type_ids_my_basic_bounded_map; + ReturnCode_t return_code_my_basic_bounded_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_basic_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_map_int32_t_anonymous_string_unbounded_10", type_ids_my_basic_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_bounded_map) + { + return_code_my_basic_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_basic_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_bounded_map) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_basic_bounded_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + bool element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec {false}; + TypeIdentifier* element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_bounded_map, element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec))}; + if (!element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int32_t_anonymous_string_unbounded_10 inconsistent element TypeIdentifier."); + return; + } + return_code_my_basic_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_basic_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_bounded_map) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Map key TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec {false}; + TypeIdentifier* key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_bounded_map, key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec))}; + if (!key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int32_t_anonymous_string_unbounded_10 inconsistent key TypeIdentifier."); + return; + } + EquivalenceKind equiv_kind_anonymous_map_int32_t_anonymous_string_unbounded_10 = EK_BOTH; + if ((EK_COMPLETE == key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() || EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d()) || + (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->seq_sdefn().header().equiv_kind()) || + (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->seq_ldefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->array_sdefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->array_ldefn().header().equiv_kind()) || + (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->map_sdefn().header().equiv_kind())) || + (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->_d() && (EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10->map_ldefn().header().equiv_kind()))) + { + equiv_kind_anonymous_map_int32_t_anonymous_string_unbounded_10 = EK_COMPLETE; + } + CollectionElementFlag element_flags_anonymous_map_int32_t_anonymous_string_unbounded_10 = 0; + CollectionElementFlag key_flags_anonymous_map_int32_t_anonymous_string_unbounded_10 = 0; + PlainCollectionHeader header_anonymous_map_int32_t_anonymous_string_unbounded_10 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_int32_t_anonymous_string_unbounded_10, element_flags_anonymous_map_int32_t_anonymous_string_unbounded_10); + { + SBound bound = static_cast(10); + PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_int32_t_anonymous_string_unbounded_10, bound, + eprosima::fastcdr::external(element_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10), key_flags_anonymous_map_int32_t_anonymous_string_unbounded_10, + eprosima::fastcdr::external(key_identifier_anonymous_map_int32_t_anonymous_string_unbounded_10)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_int32_t_anonymous_string_unbounded_10", type_ids_my_basic_bounded_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int32_t_anonymous_string_unbounded_10 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_basic_bounded_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_basic_bounded_map = 0x00000002; + bool common_my_basic_bounded_map_ec {false}; + CommonStructMember common_my_basic_bounded_map {TypeObjectUtils::build_common_struct_member(member_id_my_basic_bounded_map, member_flags_my_basic_bounded_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_bounded_map, common_my_basic_bounded_map_ec))}; + if (!common_my_basic_bounded_map_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_bounded_map member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_basic_bounded_map = "my_basic_bounded_map"; + eprosima::fastcdr::optional member_ann_builtin_my_basic_bounded_map; + ann_custom_MapStruct.reset(); + CompleteMemberDetail detail_my_basic_bounded_map = TypeObjectUtils::build_complete_member_detail(name_my_basic_bounded_map, member_ann_builtin_my_basic_bounded_map, ann_custom_MapStruct); + CompleteStructMember member_my_basic_bounded_map = TypeObjectUtils::build_complete_struct_member(common_my_basic_bounded_map, detail_my_basic_bounded_map); + TypeObjectUtils::add_complete_struct_member(member_seq_MapStruct, member_my_basic_bounded_map); + } + { + TypeIdentifierPair type_ids_my_complex_bounded_map; + ReturnCode_t return_code_my_complex_bounded_map {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_map_int16_t_ValueStruct_123", type_ids_my_complex_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_bounded_map) + { + return_code_my_complex_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ValueStruct", type_ids_my_complex_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_bounded_map) + { + ::register_ValueStruct_type_identifier(type_ids_my_complex_bounded_map); + } + bool element_identifier_anonymous_map_int16_t_ValueStruct_123_ec {false}; + TypeIdentifier* element_identifier_anonymous_map_int16_t_ValueStruct_123 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_bounded_map, element_identifier_anonymous_map_int16_t_ValueStruct_123_ec))}; + if (!element_identifier_anonymous_map_int16_t_ValueStruct_123_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int16_t_ValueStruct_123 inconsistent element TypeIdentifier."); + return; + } + return_code_my_complex_bounded_map = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_my_complex_bounded_map); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_bounded_map) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Map key TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool key_identifier_anonymous_map_int16_t_ValueStruct_123_ec {false}; + TypeIdentifier* key_identifier_anonymous_map_int16_t_ValueStruct_123 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_bounded_map, key_identifier_anonymous_map_int16_t_ValueStruct_123_ec))}; + if (!key_identifier_anonymous_map_int16_t_ValueStruct_123_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int16_t_ValueStruct_123 inconsistent key TypeIdentifier."); + return; + } + EquivalenceKind equiv_kind_anonymous_map_int16_t_ValueStruct_123 = EK_BOTH; + if ((EK_COMPLETE == key_identifier_anonymous_map_int16_t_ValueStruct_123->_d() || EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d()) || + (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->seq_sdefn().header().equiv_kind()) || + (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->seq_ldefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->array_sdefn().header().equiv_kind()) || + (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->array_ldefn().header().equiv_kind()) || + (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && (EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->map_sdefn().header().equiv_kind())) || + (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_int16_t_ValueStruct_123->_d() && (EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_int16_t_ValueStruct_123->map_ldefn().header().equiv_kind()))) + { + equiv_kind_anonymous_map_int16_t_ValueStruct_123 = EK_COMPLETE; + } + CollectionElementFlag element_flags_anonymous_map_int16_t_ValueStruct_123 = 0; + CollectionElementFlag key_flags_anonymous_map_int16_t_ValueStruct_123 = 0; + PlainCollectionHeader header_anonymous_map_int16_t_ValueStruct_123 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_int16_t_ValueStruct_123, element_flags_anonymous_map_int16_t_ValueStruct_123); + { + SBound bound = static_cast(123); + PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_int16_t_ValueStruct_123, bound, + eprosima::fastcdr::external(element_identifier_anonymous_map_int16_t_ValueStruct_123), key_flags_anonymous_map_int16_t_ValueStruct_123, + eprosima::fastcdr::external(key_identifier_anonymous_map_int16_t_ValueStruct_123)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_int16_t_ValueStruct_123", type_ids_my_complex_bounded_map)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_map_int16_t_ValueStruct_123 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_complex_bounded_map = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_complex_bounded_map = 0x00000003; + bool common_my_complex_bounded_map_ec {false}; + CommonStructMember common_my_complex_bounded_map {TypeObjectUtils::build_common_struct_member(member_id_my_complex_bounded_map, member_flags_my_complex_bounded_map, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_bounded_map, common_my_complex_bounded_map_ec))}; + if (!common_my_complex_bounded_map_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_bounded_map member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_complex_bounded_map = "my_complex_bounded_map"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_bounded_map; + ann_custom_MapStruct.reset(); + CompleteMemberDetail detail_my_complex_bounded_map = TypeObjectUtils::build_complete_member_detail(name_my_complex_bounded_map, member_ann_builtin_my_complex_bounded_map, ann_custom_MapStruct); + CompleteStructMember member_my_complex_bounded_map = TypeObjectUtils::build_complete_struct_member(common_my_complex_bounded_map, detail_my_complex_bounded_map); + TypeObjectUtils::add_complete_struct_member(member_seq_MapStruct, member_my_complex_bounded_map); + } + CompleteStructType struct_type_MapStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_MapStruct, header_MapStruct, member_seq_MapStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_map_struct, type_name_map_struct.to_string(), type_ids_map_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_MapStruct, type_name_MapStruct.to_string(), type_ids_MapStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "map_struct already registered in TypeObjectRegistry for a different type."); + "MapStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.hpp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.hpp index 4d40bbec1c7..3cadcab9a55 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/map_struct/map_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/gen/map_structTypeObjectSupport.hpp @@ -50,7 +50,7 @@ eProsima_user_DllExport void register_ValueStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register map_struct related TypeIdentifier. + * @brief Register MapStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,7 +59,7 @@ eProsima_user_DllExport void register_ValueStruct_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_map_struct_type_identifier( +eProsima_user_DllExport void register_MapStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl similarity index 52% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl index 0f09ef8b587..b0f70f92594 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/map_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl @@ -3,8 +3,10 @@ struct ValueStruct boolean value; }; -struct map_struct +struct MapStruct { map my_basic_map; map my_complex_map; + map my_basic_bounded_map; + map my_complex_bounded_map; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_struct.hpp new file mode 100644 index 00000000000..ca3e3ae5439 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_struct.hpp @@ -0,0 +1,673 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file sequence_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__SEQUENCE_STRUCT_HPP +#define FAST_DDS_GENERATED__SEQUENCE_STRUCT_HPP + +#include +#include +#include +#include + +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(SEQUENCE_STRUCT_SOURCE) +#define SEQUENCE_STRUCT_DllAPI __declspec( dllexport ) +#else +#define SEQUENCE_STRUCT_DllAPI __declspec( dllimport ) +#endif // SEQUENCE_STRUCT_SOURCE +#else +#define SEQUENCE_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define SEQUENCE_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure NestedSequenceElement defined by the user in the IDL file. + * @ingroup sequence_struct + */ +class NestedSequenceElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport NestedSequenceElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~NestedSequenceElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object NestedSequenceElement that will be copied. + */ + eProsima_user_DllExport NestedSequenceElement( + const NestedSequenceElement& x) + { + m_my_string = x.m_my_string; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object NestedSequenceElement that will be copied. + */ + eProsima_user_DllExport NestedSequenceElement( + NestedSequenceElement&& x) noexcept + { + m_my_string = std::move(x.m_my_string); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object NestedSequenceElement that will be copied. + */ + eProsima_user_DllExport NestedSequenceElement& operator =( + const NestedSequenceElement& x) + { + + m_my_string = x.m_my_string; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object NestedSequenceElement that will be copied. + */ + eProsima_user_DllExport NestedSequenceElement& operator =( + NestedSequenceElement&& x) noexcept + { + + m_my_string = std::move(x.m_my_string); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x NestedSequenceElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const NestedSequenceElement& x) const + { + return (m_my_string == x.m_my_string); + } + + /*! + * @brief Comparison operator. + * @param x NestedSequenceElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const NestedSequenceElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_string + * @param _my_string New value to be copied in member my_string + */ + eProsima_user_DllExport void my_string( + const std::string& _my_string) + { + m_my_string = _my_string; + } + + /*! + * @brief This function moves the value in member my_string + * @param _my_string New value to be moved in member my_string + */ + eProsima_user_DllExport void my_string( + std::string&& _my_string) + { + m_my_string = std::move(_my_string); + } + + /*! + * @brief This function returns a constant reference to member my_string + * @return Constant reference to member my_string + */ + eProsima_user_DllExport const std::string& my_string() const + { + return m_my_string; + } + + /*! + * @brief This function returns a reference to member my_string + * @return Reference to member my_string + */ + eProsima_user_DllExport std::string& my_string() + { + return m_my_string; + } + + + +private: + + std::string m_my_string; + +}; +/*! + * @brief This class represents the structure ComplexSequenceElement defined by the user in the IDL file. + * @ingroup sequence_struct + */ +class ComplexSequenceElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ComplexSequenceElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ComplexSequenceElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ComplexSequenceElement that will be copied. + */ + eProsima_user_DllExport ComplexSequenceElement( + const ComplexSequenceElement& x) + { + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_complex_element = x.m_my_complex_element; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ComplexSequenceElement that will be copied. + */ + eProsima_user_DllExport ComplexSequenceElement( + ComplexSequenceElement&& x) noexcept + { + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_complex_element = std::move(x.m_my_complex_element); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ComplexSequenceElement that will be copied. + */ + eProsima_user_DllExport ComplexSequenceElement& operator =( + const ComplexSequenceElement& x) + { + + m_my_short = x.m_my_short; + + m_my_long = x.m_my_long; + + m_my_complex_element = x.m_my_complex_element; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ComplexSequenceElement that will be copied. + */ + eProsima_user_DllExport ComplexSequenceElement& operator =( + ComplexSequenceElement&& x) noexcept + { + + m_my_short = x.m_my_short; + m_my_long = x.m_my_long; + m_my_complex_element = std::move(x.m_my_complex_element); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ComplexSequenceElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ComplexSequenceElement& x) const + { + return (m_my_short == x.m_my_short && + m_my_long == x.m_my_long && + m_my_complex_element == x.m_my_complex_element); + } + + /*! + * @brief Comparison operator. + * @param x ComplexSequenceElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ComplexSequenceElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short + */ + eProsima_user_DllExport void my_short( + int16_t _my_short) + { + m_my_short = _my_short; + } + + /*! + * @brief This function returns the value of member my_short + * @return Value of member my_short + */ + eProsima_user_DllExport int16_t my_short() const + { + return m_my_short; + } + + /*! + * @brief This function returns a reference to member my_short + * @return Reference to member my_short + */ + eProsima_user_DllExport int16_t& my_short() + { + return m_my_short; + } + + + /*! + * @brief This function sets a value in member my_long + * @param _my_long New value for member my_long + */ + eProsima_user_DllExport void my_long( + int32_t _my_long) + { + m_my_long = _my_long; + } + + /*! + * @brief This function returns the value of member my_long + * @return Value of member my_long + */ + eProsima_user_DllExport int32_t my_long() const + { + return m_my_long; + } + + /*! + * @brief This function returns a reference to member my_long + * @return Reference to member my_long + */ + eProsima_user_DllExport int32_t& my_long() + { + return m_my_long; + } + + + /*! + * @brief This function copies the value in member my_complex_element + * @param _my_complex_element New value to be copied in member my_complex_element + */ + eProsima_user_DllExport void my_complex_element( + const NestedSequenceElement& _my_complex_element) + { + m_my_complex_element = _my_complex_element; + } + + /*! + * @brief This function moves the value in member my_complex_element + * @param _my_complex_element New value to be moved in member my_complex_element + */ + eProsima_user_DllExport void my_complex_element( + NestedSequenceElement&& _my_complex_element) + { + m_my_complex_element = std::move(_my_complex_element); + } + + /*! + * @brief This function returns a constant reference to member my_complex_element + * @return Constant reference to member my_complex_element + */ + eProsima_user_DllExport const NestedSequenceElement& my_complex_element() const + { + return m_my_complex_element; + } + + /*! + * @brief This function returns a reference to member my_complex_element + * @return Reference to member my_complex_element + */ + eProsima_user_DllExport NestedSequenceElement& my_complex_element() + { + return m_my_complex_element; + } + + + +private: + + int16_t m_my_short{0}; + int32_t m_my_long{0}; + NestedSequenceElement m_my_complex_element; + +}; +/*! + * @brief This class represents the structure SequenceStruct defined by the user in the IDL file. + * @ingroup sequence_struct + */ +class SequenceStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport SequenceStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~SequenceStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object SequenceStruct that will be copied. + */ + eProsima_user_DllExport SequenceStruct( + const SequenceStruct& x) + { + m_my_basic_sequence = x.m_my_basic_sequence; + + m_my_bounded_sequence = x.m_my_bounded_sequence; + + m_my_complex_sequence = x.m_my_complex_sequence; + + m_my_complex_bounded_sequence = x.m_my_complex_bounded_sequence; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object SequenceStruct that will be copied. + */ + eProsima_user_DllExport SequenceStruct( + SequenceStruct&& x) noexcept + { + m_my_basic_sequence = std::move(x.m_my_basic_sequence); + m_my_bounded_sequence = std::move(x.m_my_bounded_sequence); + m_my_complex_sequence = std::move(x.m_my_complex_sequence); + m_my_complex_bounded_sequence = std::move(x.m_my_complex_bounded_sequence); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object SequenceStruct that will be copied. + */ + eProsima_user_DllExport SequenceStruct& operator =( + const SequenceStruct& x) + { + + m_my_basic_sequence = x.m_my_basic_sequence; + + m_my_bounded_sequence = x.m_my_bounded_sequence; + + m_my_complex_sequence = x.m_my_complex_sequence; + + m_my_complex_bounded_sequence = x.m_my_complex_bounded_sequence; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object SequenceStruct that will be copied. + */ + eProsima_user_DllExport SequenceStruct& operator =( + SequenceStruct&& x) noexcept + { + + m_my_basic_sequence = std::move(x.m_my_basic_sequence); + m_my_bounded_sequence = std::move(x.m_my_bounded_sequence); + m_my_complex_sequence = std::move(x.m_my_complex_sequence); + m_my_complex_bounded_sequence = std::move(x.m_my_complex_bounded_sequence); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x SequenceStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const SequenceStruct& x) const + { + return (m_my_basic_sequence == x.m_my_basic_sequence && + m_my_bounded_sequence == x.m_my_bounded_sequence && + m_my_complex_sequence == x.m_my_complex_sequence && + m_my_complex_bounded_sequence == x.m_my_complex_bounded_sequence); + } + + /*! + * @brief Comparison operator. + * @param x SequenceStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const SequenceStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_basic_sequence + * @param _my_basic_sequence New value to be copied in member my_basic_sequence + */ + eProsima_user_DllExport void my_basic_sequence( + const std::vector& _my_basic_sequence) + { + m_my_basic_sequence = _my_basic_sequence; + } + + /*! + * @brief This function moves the value in member my_basic_sequence + * @param _my_basic_sequence New value to be moved in member my_basic_sequence + */ + eProsima_user_DllExport void my_basic_sequence( + std::vector&& _my_basic_sequence) + { + m_my_basic_sequence = std::move(_my_basic_sequence); + } + + /*! + * @brief This function returns a constant reference to member my_basic_sequence + * @return Constant reference to member my_basic_sequence + */ + eProsima_user_DllExport const std::vector& my_basic_sequence() const + { + return m_my_basic_sequence; + } + + /*! + * @brief This function returns a reference to member my_basic_sequence + * @return Reference to member my_basic_sequence + */ + eProsima_user_DllExport std::vector& my_basic_sequence() + { + return m_my_basic_sequence; + } + + + /*! + * @brief This function copies the value in member my_bounded_sequence + * @param _my_bounded_sequence New value to be copied in member my_bounded_sequence + */ + eProsima_user_DllExport void my_bounded_sequence( + const std::vector& _my_bounded_sequence) + { + m_my_bounded_sequence = _my_bounded_sequence; + } + + /*! + * @brief This function moves the value in member my_bounded_sequence + * @param _my_bounded_sequence New value to be moved in member my_bounded_sequence + */ + eProsima_user_DllExport void my_bounded_sequence( + std::vector&& _my_bounded_sequence) + { + m_my_bounded_sequence = std::move(_my_bounded_sequence); + } + + /*! + * @brief This function returns a constant reference to member my_bounded_sequence + * @return Constant reference to member my_bounded_sequence + */ + eProsima_user_DllExport const std::vector& my_bounded_sequence() const + { + return m_my_bounded_sequence; + } + + /*! + * @brief This function returns a reference to member my_bounded_sequence + * @return Reference to member my_bounded_sequence + */ + eProsima_user_DllExport std::vector& my_bounded_sequence() + { + return m_my_bounded_sequence; + } + + + /*! + * @brief This function copies the value in member my_complex_sequence + * @param _my_complex_sequence New value to be copied in member my_complex_sequence + */ + eProsima_user_DllExport void my_complex_sequence( + const std::vector& _my_complex_sequence) + { + m_my_complex_sequence = _my_complex_sequence; + } + + /*! + * @brief This function moves the value in member my_complex_sequence + * @param _my_complex_sequence New value to be moved in member my_complex_sequence + */ + eProsima_user_DllExport void my_complex_sequence( + std::vector&& _my_complex_sequence) + { + m_my_complex_sequence = std::move(_my_complex_sequence); + } + + /*! + * @brief This function returns a constant reference to member my_complex_sequence + * @return Constant reference to member my_complex_sequence + */ + eProsima_user_DllExport const std::vector& my_complex_sequence() const + { + return m_my_complex_sequence; + } + + /*! + * @brief This function returns a reference to member my_complex_sequence + * @return Reference to member my_complex_sequence + */ + eProsima_user_DllExport std::vector& my_complex_sequence() + { + return m_my_complex_sequence; + } + + + /*! + * @brief This function copies the value in member my_complex_bounded_sequence + * @param _my_complex_bounded_sequence New value to be copied in member my_complex_bounded_sequence + */ + eProsima_user_DllExport void my_complex_bounded_sequence( + const std::vector& _my_complex_bounded_sequence) + { + m_my_complex_bounded_sequence = _my_complex_bounded_sequence; + } + + /*! + * @brief This function moves the value in member my_complex_bounded_sequence + * @param _my_complex_bounded_sequence New value to be moved in member my_complex_bounded_sequence + */ + eProsima_user_DllExport void my_complex_bounded_sequence( + std::vector&& _my_complex_bounded_sequence) + { + m_my_complex_bounded_sequence = std::move(_my_complex_bounded_sequence); + } + + /*! + * @brief This function returns a constant reference to member my_complex_bounded_sequence + * @return Constant reference to member my_complex_bounded_sequence + */ + eProsima_user_DllExport const std::vector& my_complex_bounded_sequence() const + { + return m_my_complex_bounded_sequence; + } + + /*! + * @brief This function returns a reference to member my_complex_bounded_sequence + * @return Reference to member my_complex_bounded_sequence + */ + eProsima_user_DllExport std::vector& my_complex_bounded_sequence() + { + return m_my_complex_bounded_sequence; + } + + + +private: + + std::vector m_my_basic_sequence; + std::vector m_my_bounded_sequence; + std::vector m_my_complex_sequence; + std::vector m_my_complex_bounded_sequence; + +}; + +#endif // _FAST_DDS_GENERATED_SEQUENCE_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.hpp similarity index 56% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.hpp index d777ee1c1c2..0d16d1bd995 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/arrays_and_sequences/arrays_and_sequencesCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.hpp @@ -13,22 +13,25 @@ // limitations under the License. /*! - * @file arrays_and_sequencesCdrAux.hpp + * @file sequence_structCdrAux.hpp * This source file contains some definitions of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP -#define FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP +#ifndef FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_HPP -#include "arrays_and_sequences.hpp" +#include "sequence_struct.hpp" -constexpr uint32_t arrays_and_sequences_max_cdr_typesize {261UL}; -constexpr uint32_t arrays_and_sequences_max_key_cdr_typesize {0UL}; +constexpr uint32_t NestedSequenceElement_max_cdr_typesize {264UL}; +constexpr uint32_t NestedSequenceElement_max_key_cdr_typesize {0UL}; -constexpr uint32_t AnInternalObject_max_cdr_typesize {9UL}; -constexpr uint32_t AnInternalObject_max_key_cdr_typesize {0UL}; +constexpr uint32_t ComplexSequenceElement_max_cdr_typesize {276UL}; +constexpr uint32_t ComplexSequenceElement_max_key_cdr_typesize {0UL}; + +constexpr uint32_t SequenceStruct_max_cdr_typesize {34028UL}; +constexpr uint32_t SequenceStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -39,15 +42,19 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const AnInternalObject& data); + const NestedSequenceElement& data); + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const ComplexSequenceElement& data); eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const arrays_and_sequences& data); + const SequenceStruct& data); } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__ARRAYS_AND_SEQUENCESCDRAUX_HPP +#endif // FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.ipp similarity index 53% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.ipp index 48b72fb8b7c..4e06b7efdee 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/multi_array_struct/multi_array_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structCdrAux.ipp @@ -13,16 +13,16 @@ // limitations under the License. /*! - * @file multi_array_structCdrAux.ipp + * @file sequence_structCdrAux.ipp * This source file contains some declarations of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP -#define FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP +#ifndef FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_IPP -#include "multi_array_structCdrAux.hpp" +#include "sequence_structCdrAux.hpp" #include #include @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const ColorAmount& data, + const NestedSequenceElement& data, size_t& current_alignment) { static_cast(data); @@ -51,13 +51,89 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.red(), current_alignment); + data.my_string(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const NestedSequenceElement& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_string() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + NestedSequenceElement& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_string(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const NestedSequenceElement& data) +{ + static_cast(scdr); + static_cast(data); +} + + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const ComplexSequenceElement& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_short(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.green(), current_alignment); + data.my_long(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.blue(), current_alignment); + data.my_complex_element(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -68,7 +144,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const ColorAmount& data) + const ComplexSequenceElement& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -77,9 +153,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.red() - << eprosima::fastcdr::MemberId(1) << data.green() - << eprosima::fastcdr::MemberId(2) << data.blue() + << eprosima::fastcdr::MemberId(0) << data.my_short() + << eprosima::fastcdr::MemberId(1) << data.my_long() + << eprosima::fastcdr::MemberId(2) << data.my_complex_element() ; scdr.end_serialize_type(current_state); } @@ -87,7 +163,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - ColorAmount& data) + ComplexSequenceElement& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -98,15 +174,15 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.red(); + dcdr >> data.my_short(); break; case 1: - dcdr >> data.green(); + dcdr >> data.my_long(); break; case 2: - dcdr >> data.blue(); + dcdr >> data.my_complex_element(); break; default: @@ -119,7 +195,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const ColorAmount& data) + const ComplexSequenceElement& data) { static_cast(scdr); static_cast(data); @@ -129,7 +205,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const multi_array_struct& data, + const SequenceStruct& data, size_t& current_alignment) { static_cast(data); @@ -143,7 +219,16 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.colors(), current_alignment); + data.my_basic_sequence(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_bounded_sequence(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_complex_sequence(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_complex_bounded_sequence(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -154,7 +239,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const multi_array_struct& data) + const SequenceStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -163,7 +248,10 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.colors() + << eprosima::fastcdr::MemberId(0) << data.my_basic_sequence() + << eprosima::fastcdr::MemberId(1) << data.my_bounded_sequence() + << eprosima::fastcdr::MemberId(2) << data.my_complex_sequence() + << eprosima::fastcdr::MemberId(3) << data.my_complex_bounded_sequence() ; scdr.end_serialize_type(current_state); } @@ -171,7 +259,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - multi_array_struct& data) + SequenceStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -182,7 +270,19 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.colors(); + dcdr >> data.my_basic_sequence(); + break; + + case 1: + dcdr >> data.my_bounded_sequence(); + break; + + case 2: + dcdr >> data.my_complex_sequence(); + break; + + case 3: + dcdr >> data.my_complex_bounded_sequence(); break; default: @@ -195,7 +295,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const multi_array_struct& data) + const SequenceStruct& data) { static_cast(scdr); static_cast(data); @@ -206,5 +306,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__MULTI_ARRAY_STRUCTCDRAUX_IPP +#endif // FAST_DDS_GENERATED__SEQUENCE_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.cxx similarity index 54% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.cxx index 88043626bce..406a1041ea5 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.cxx @@ -13,42 +13,42 @@ // limitations under the License. /*! - * @file basic_array_structPubSubTypes.cpp + * @file sequence_structPubSubTypes.cpp * This header file contains the implementation of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#include "basic_array_structPubSubTypes.hpp" +#include "sequence_structPubSubTypes.hpp" #include #include -#include "basic_array_structCdrAux.hpp" -#include "basic_array_structTypeObjectSupport.hpp" +#include "sequence_structCdrAux.hpp" +#include "sequence_structTypeObjectSupport.hpp" using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -TheOtherObjectInArrayPubSubType::TheOtherObjectInArrayPubSubType() +NestedSequenceElementPubSubType::NestedSequenceElementPubSubType() { - setName("TheOtherObjectInArray"); + setName("NestedSequenceElement"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(TheOtherObjectInArray::getMaxCdrSerializedSize()); + static_cast(NestedSequenceElement::getMaxCdrSerializedSize()); #else - TheOtherObjectInArray_max_cdr_typesize; + NestedSequenceElement_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = TheOtherObjectInArray_max_key_cdr_typesize > 16 ? TheOtherObjectInArray_max_key_cdr_typesize : 16; + uint32_t keyLength = NestedSequenceElement_max_key_cdr_typesize > 16 ? NestedSequenceElement_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -TheOtherObjectInArrayPubSubType::~TheOtherObjectInArrayPubSubType() +NestedSequenceElementPubSubType::~NestedSequenceElementPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ TheOtherObjectInArrayPubSubType::~TheOtherObjectInArrayPubSubType() } } -bool TheOtherObjectInArrayPubSubType::serialize( +bool NestedSequenceElementPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const TheOtherObjectInArray* p_type = static_cast(data); + const NestedSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool TheOtherObjectInArrayPubSubType::serialize( return true; } -bool TheOtherObjectInArrayPubSubType::deserialize( +bool NestedSequenceElementPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - TheOtherObjectInArray* p_type = static_cast(data); + NestedSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool TheOtherObjectInArrayPubSubType::deserialize( return true; } -std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProvider( +std::function NestedSequenceElementPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProv { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProv eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function TheOtherObjectInArrayPubSubType::getSerializedSizeProv }; } -void* TheOtherObjectInArrayPubSubType::createData() +void* NestedSequenceElementPubSubType::createData() { - return reinterpret_cast(new TheOtherObjectInArray()); + return reinterpret_cast(new NestedSequenceElement()); } -void TheOtherObjectInArrayPubSubType::deleteData( +void NestedSequenceElementPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool TheOtherObjectInArrayPubSubType::getKey( +bool NestedSequenceElementPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool TheOtherObjectInArrayPubSubType::getKey( return false; } - const TheOtherObjectInArray* p_type = static_cast(data); + const NestedSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - TheOtherObjectInArray_max_key_cdr_typesize); + NestedSequenceElement_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool TheOtherObjectInArrayPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || TheOtherObjectInArray_max_key_cdr_typesize > 16) + if (force_md5 || NestedSequenceElement_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,29 +219,29 @@ bool TheOtherObjectInArrayPubSubType::getKey( return true; } -void TheOtherObjectInArrayPubSubType::register_type_object_representation() +void NestedSequenceElementPubSubType::register_type_object_representation() { - register_TheOtherObjectInArray_type_identifier(type_identifiers_); + register_NestedSequenceElement_type_identifier(type_identifiers_); } -basic_array_structPubSubType::basic_array_structPubSubType() +ComplexSequenceElementPubSubType::ComplexSequenceElementPubSubType() { - setName("basic_array_struct"); + setName("ComplexSequenceElement"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(basic_array_struct::getMaxCdrSerializedSize()); + static_cast(ComplexSequenceElement::getMaxCdrSerializedSize()); #else - basic_array_struct_max_cdr_typesize; + ComplexSequenceElement_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = basic_array_struct_max_key_cdr_typesize > 16 ? basic_array_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = ComplexSequenceElement_max_key_cdr_typesize > 16 ? ComplexSequenceElement_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -basic_array_structPubSubType::~basic_array_structPubSubType() +ComplexSequenceElementPubSubType::~ComplexSequenceElementPubSubType() { if (m_keyBuffer != nullptr) { @@ -249,12 +249,12 @@ basic_array_structPubSubType::~basic_array_structPubSubType() } } -bool basic_array_structPubSubType::serialize( +bool ComplexSequenceElementPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const basic_array_struct* p_type = static_cast(data); + const ComplexSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -291,14 +291,14 @@ bool basic_array_structPubSubType::serialize( return true; } -bool basic_array_structPubSubType::deserialize( +bool ComplexSequenceElementPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - basic_array_struct* p_type = static_cast(data); + ComplexSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -325,7 +325,7 @@ bool basic_array_structPubSubType::deserialize( return true; } -std::function basic_array_structPubSubType::getSerializedSizeProvider( +std::function ComplexSequenceElementPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -333,7 +333,7 @@ std::function basic_array_structPubSubType::getSerializedSizeProvide { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -343,7 +343,7 @@ std::function basic_array_structPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -354,18 +354,18 @@ std::function basic_array_structPubSubType::getSerializedSizeProvide }; } -void* basic_array_structPubSubType::createData() +void* ComplexSequenceElementPubSubType::createData() { - return reinterpret_cast(new basic_array_struct()); + return reinterpret_cast(new ComplexSequenceElement()); } -void basic_array_structPubSubType::deleteData( +void ComplexSequenceElementPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool basic_array_structPubSubType::getKey( +bool ComplexSequenceElementPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -375,11 +375,11 @@ bool basic_array_structPubSubType::getKey( return false; } - const basic_array_struct* p_type = static_cast(data); + const ComplexSequenceElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - basic_array_struct_max_key_cdr_typesize); + ComplexSequenceElement_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -388,7 +388,7 @@ bool basic_array_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || basic_array_struct_max_key_cdr_typesize > 16) + if (force_md5 || ComplexSequenceElement_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -412,11 +412,204 @@ bool basic_array_structPubSubType::getKey( return true; } -void basic_array_structPubSubType::register_type_object_representation() +void ComplexSequenceElementPubSubType::register_type_object_representation() { - register_basic_array_struct_type_identifier(type_identifiers_); + register_ComplexSequenceElement_type_identifier(type_identifiers_); +} + +SequenceStructPubSubType::SequenceStructPubSubType() +{ + setName("SequenceStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(SequenceStruct::getMaxCdrSerializedSize()); +#else + SequenceStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = SequenceStruct_max_key_cdr_typesize > 16 ? SequenceStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +SequenceStructPubSubType::~SequenceStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool SequenceStructPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const SequenceStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool SequenceStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + SequenceStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function SequenceStructPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* SequenceStructPubSubType::createData() +{ + return reinterpret_cast(new SequenceStruct()); +} + +void SequenceStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool SequenceStructPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const SequenceStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + SequenceStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || SequenceStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void SequenceStructPubSubType::register_type_object_representation() +{ + register_SequenceStruct_type_identifier(type_identifiers_); } // Include auxiliary functions like for serializing/deserializing. -#include "basic_array_structCdrAux.ipp" +#include "sequence_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.hpp similarity index 59% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.hpp index 057e6dda7c6..d0c2498530d 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structPubSubTypes.hpp @@ -13,15 +13,15 @@ // limitations under the License. /*! - * @file basic_array_structPubSubTypes.hpp + * @file sequence_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP +#ifndef FAST_DDS_GENERATED__SEQUENCE_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__SEQUENCE_STRUCT_PUBSUBTYPES_HPP #include #include @@ -29,28 +29,28 @@ #include #include -#include "basic_array_struct.hpp" +#include "sequence_struct.hpp" #if !defined(GEN_API_VER) || (GEN_API_VER != 2) #error \ - Generated basic_array_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. + Generated sequence_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // GEN_API_VER /*! - * @brief This class represents the TopicDataType of the type TheOtherObjectInArray defined by the user in the IDL file. - * @ingroup basic_array_struct + * @brief This class represents the TopicDataType of the type NestedSequenceElement defined by the user in the IDL file. + * @ingroup sequence_struct */ -class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicDataType +class NestedSequenceElementPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef TheOtherObjectInArray type; + typedef NestedSequenceElement type; - eProsima_user_DllExport TheOtherObjectInArrayPubSubType(); + eProsima_user_DllExport NestedSequenceElementPubSubType(); - eProsima_user_DllExport ~TheOtherObjectInArrayPubSubType() override; + eProsima_user_DllExport ~NestedSequenceElementPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -94,7 +94,7 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -130,18 +130,18 @@ class TheOtherObjectInArrayPubSubType : public eprosima::fastdds::dds::TopicData }; /*! - * @brief This class represents the TopicDataType of the type basic_array_struct defined by the user in the IDL file. - * @ingroup basic_array_struct + * @brief This class represents the TopicDataType of the type ComplexSequenceElement defined by the user in the IDL file. + * @ingroup sequence_struct */ -class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class ComplexSequenceElementPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef basic_array_struct type; + typedef ComplexSequenceElement type; - eProsima_user_DllExport basic_array_structPubSubType(); + eProsima_user_DllExport ComplexSequenceElementPubSubType(); - eProsima_user_DllExport ~basic_array_structPubSubType() override; + eProsima_user_DllExport ~ComplexSequenceElementPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -185,7 +185,98 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +/*! + * @brief This class represents the TopicDataType of the type SequenceStruct defined by the user in the IDL file. + * @ingroup sequence_struct + */ +class SequenceStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef SequenceStruct type; + + eProsima_user_DllExport SequenceStructPubSubType(); + + eProsima_user_DllExport ~SequenceStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -220,5 +311,5 @@ class basic_array_structPubSubType : public eprosima::fastdds::dds::TopicDataTyp }; -#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_PUBSUBTYPES_HPP +#endif // FAST_DDS_GENERATED__SEQUENCE_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..3a9201f6dbe --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.cxx @@ -0,0 +1,498 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file sequence_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "sequence_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sequence_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_NestedSequenceElement_type_identifier( + TypeIdentifierPair& type_ids_NestedSequenceElement) +{ + + ReturnCode_t return_code_NestedSequenceElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_NestedSequenceElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedSequenceElement", type_ids_NestedSequenceElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_NestedSequenceElement) + { + StructTypeFlag struct_flags_NestedSequenceElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_NestedSequenceElement = "NestedSequenceElement"; + eprosima::fastcdr::optional type_ann_builtin_NestedSequenceElement; + eprosima::fastcdr::optional ann_custom_NestedSequenceElement; + CompleteTypeDetail detail_NestedSequenceElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_NestedSequenceElement, ann_custom_NestedSequenceElement, type_name_NestedSequenceElement.to_string()); + CompleteStructHeader header_NestedSequenceElement; + header_NestedSequenceElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_NestedSequenceElement); + CompleteStructMemberSeq member_seq_NestedSequenceElement; + { + TypeIdentifierPair type_ids_my_string; + ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_string) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_string = 0x00000000; + bool common_my_string_ec {false}; + CommonStructMember common_my_string {TypeObjectUtils::build_common_struct_member(member_id_my_string, member_flags_my_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_string, common_my_string_ec))}; + if (!common_my_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_string = "my_string"; + eprosima::fastcdr::optional member_ann_builtin_my_string; + ann_custom_NestedSequenceElement.reset(); + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_NestedSequenceElement); + CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_NestedSequenceElement, member_my_string); + } + CompleteStructType struct_type_NestedSequenceElement = TypeObjectUtils::build_complete_struct_type(struct_flags_NestedSequenceElement, header_NestedSequenceElement, member_seq_NestedSequenceElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_NestedSequenceElement, type_name_NestedSequenceElement.to_string(), type_ids_NestedSequenceElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "NestedSequenceElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ComplexSequenceElement_type_identifier( + TypeIdentifierPair& type_ids_ComplexSequenceElement) +{ + + ReturnCode_t return_code_ComplexSequenceElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ComplexSequenceElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexSequenceElement", type_ids_ComplexSequenceElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ComplexSequenceElement) + { + StructTypeFlag struct_flags_ComplexSequenceElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_ComplexSequenceElement = "ComplexSequenceElement"; + eprosima::fastcdr::optional type_ann_builtin_ComplexSequenceElement; + eprosima::fastcdr::optional ann_custom_ComplexSequenceElement; + CompleteTypeDetail detail_ComplexSequenceElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ComplexSequenceElement, ann_custom_ComplexSequenceElement, type_name_ComplexSequenceElement.to_string()); + CompleteStructHeader header_ComplexSequenceElement; + header_ComplexSequenceElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ComplexSequenceElement); + CompleteStructMemberSeq member_seq_ComplexSequenceElement; + { + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_my_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_short Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_short = 0x00000000; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; + ann_custom_ComplexSequenceElement.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_ComplexSequenceElement); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexSequenceElement, member_my_short); + } + { + TypeIdentifierPair type_ids_my_long; + ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_long = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_long); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_long) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_long Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_long = 0x00000001; + bool common_my_long_ec {false}; + CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; + if (!common_my_long_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_long member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_long = "my_long"; + eprosima::fastcdr::optional member_ann_builtin_my_long; + ann_custom_ComplexSequenceElement.reset(); + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_ComplexSequenceElement); + CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexSequenceElement, member_my_long); + } + { + TypeIdentifierPair type_ids_my_complex_element; + ReturnCode_t return_code_my_complex_element {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_element = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedSequenceElement", type_ids_my_complex_element); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_element) + { + ::register_NestedSequenceElement_type_identifier(type_ids_my_complex_element); + } + StructMemberFlag member_flags_my_complex_element = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_complex_element = 0x00000002; + bool common_my_complex_element_ec {false}; + CommonStructMember common_my_complex_element {TypeObjectUtils::build_common_struct_member(member_id_my_complex_element, member_flags_my_complex_element, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_element, common_my_complex_element_ec))}; + if (!common_my_complex_element_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_element member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_complex_element = "my_complex_element"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_element; + ann_custom_ComplexSequenceElement.reset(); + CompleteMemberDetail detail_my_complex_element = TypeObjectUtils::build_complete_member_detail(name_my_complex_element, member_ann_builtin_my_complex_element, ann_custom_ComplexSequenceElement); + CompleteStructMember member_my_complex_element = TypeObjectUtils::build_complete_struct_member(common_my_complex_element, detail_my_complex_element); + TypeObjectUtils::add_complete_struct_member(member_seq_ComplexSequenceElement, member_my_complex_element); + } + CompleteStructType struct_type_ComplexSequenceElement = TypeObjectUtils::build_complete_struct_type(struct_flags_ComplexSequenceElement, header_ComplexSequenceElement, member_seq_ComplexSequenceElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ComplexSequenceElement, type_name_ComplexSequenceElement.to_string(), type_ids_ComplexSequenceElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ComplexSequenceElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_SequenceStruct_type_identifier( + TypeIdentifierPair& type_ids_SequenceStruct) +{ + + ReturnCode_t return_code_SequenceStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_SequenceStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "SequenceStruct", type_ids_SequenceStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_SequenceStruct) + { + StructTypeFlag struct_flags_SequenceStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_SequenceStruct = "SequenceStruct"; + eprosima::fastcdr::optional type_ann_builtin_SequenceStruct; + eprosima::fastcdr::optional ann_custom_SequenceStruct; + CompleteTypeDetail detail_SequenceStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SequenceStruct, ann_custom_SequenceStruct, type_name_SequenceStruct.to_string()); + CompleteStructHeader header_SequenceStruct; + header_SequenceStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SequenceStruct); + CompleteStructMemberSeq member_seq_SequenceStruct; + { + TypeIdentifierPair type_ids_my_basic_sequence; + ReturnCode_t return_code_my_basic_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_basic_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_char_unbounded", type_ids_my_basic_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_sequence) + { + return_code_my_basic_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_char", type_ids_my_basic_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_sequence) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_sequence_char_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_char_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_sequence, element_identifier_anonymous_sequence_char_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_char_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_char_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_my_basic_sequence.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_char_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_char_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_char_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_char_unbounded, element_flags_anonymous_sequence_char_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_char_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_char_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_char_unbounded", type_ids_my_basic_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_char_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_basic_sequence = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_basic_sequence = 0x00000000; + bool common_my_basic_sequence_ec {false}; + CommonStructMember common_my_basic_sequence {TypeObjectUtils::build_common_struct_member(member_id_my_basic_sequence, member_flags_my_basic_sequence, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_sequence, common_my_basic_sequence_ec))}; + if (!common_my_basic_sequence_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_sequence member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_basic_sequence = "my_basic_sequence"; + eprosima::fastcdr::optional member_ann_builtin_my_basic_sequence; + ann_custom_SequenceStruct.reset(); + CompleteMemberDetail detail_my_basic_sequence = TypeObjectUtils::build_complete_member_detail(name_my_basic_sequence, member_ann_builtin_my_basic_sequence, ann_custom_SequenceStruct); + CompleteStructMember member_my_basic_sequence = TypeObjectUtils::build_complete_struct_member(common_my_basic_sequence, detail_my_basic_sequence); + TypeObjectUtils::add_complete_struct_member(member_seq_SequenceStruct, member_my_basic_sequence); + } + { + TypeIdentifierPair type_ids_my_bounded_sequence; + ReturnCode_t return_code_my_bounded_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bounded_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_float_13", type_ids_my_bounded_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bounded_sequence) + { + return_code_my_bounded_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_float", type_ids_my_bounded_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bounded_sequence) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "Sequence element TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool element_identifier_anonymous_sequence_float_13_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_float_13 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bounded_sequence, element_identifier_anonymous_sequence_float_13_ec))}; + if (!element_identifier_anonymous_sequence_float_13_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_float_13 = EK_COMPLETE; + if (TK_NONE == type_ids_my_bounded_sequence.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_float_13 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_float_13 = 0; + PlainCollectionHeader header_anonymous_sequence_float_13 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_float_13, element_flags_anonymous_sequence_float_13); + { + SBound bound = static_cast(13); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_float_13, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_float_13)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_float_13", type_ids_my_bounded_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_float_13 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_bounded_sequence = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bounded_sequence = 0x00000001; + bool common_my_bounded_sequence_ec {false}; + CommonStructMember common_my_bounded_sequence {TypeObjectUtils::build_common_struct_member(member_id_my_bounded_sequence, member_flags_my_bounded_sequence, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bounded_sequence, common_my_bounded_sequence_ec))}; + if (!common_my_bounded_sequence_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bounded_sequence member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bounded_sequence = "my_bounded_sequence"; + eprosima::fastcdr::optional member_ann_builtin_my_bounded_sequence; + ann_custom_SequenceStruct.reset(); + CompleteMemberDetail detail_my_bounded_sequence = TypeObjectUtils::build_complete_member_detail(name_my_bounded_sequence, member_ann_builtin_my_bounded_sequence, ann_custom_SequenceStruct); + CompleteStructMember member_my_bounded_sequence = TypeObjectUtils::build_complete_struct_member(common_my_bounded_sequence, detail_my_bounded_sequence); + TypeObjectUtils::add_complete_struct_member(member_seq_SequenceStruct, member_my_bounded_sequence); + } + { + TypeIdentifierPair type_ids_my_complex_sequence; + ReturnCode_t return_code_my_complex_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_ComplexSequenceElement_unbounded", type_ids_my_complex_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_sequence) + { + return_code_my_complex_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexSequenceElement", type_ids_my_complex_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_sequence) + { + ::register_ComplexSequenceElement_type_identifier(type_ids_my_complex_sequence); + } + bool element_identifier_anonymous_sequence_ComplexSequenceElement_unbounded_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_ComplexSequenceElement_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_sequence, element_identifier_anonymous_sequence_ComplexSequenceElement_unbounded_ec))}; + if (!element_identifier_anonymous_sequence_ComplexSequenceElement_unbounded_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_ComplexSequenceElement_unbounded = EK_COMPLETE; + if (TK_NONE == type_ids_my_complex_sequence.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_ComplexSequenceElement_unbounded = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_ComplexSequenceElement_unbounded = 0; + PlainCollectionHeader header_anonymous_sequence_ComplexSequenceElement_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_ComplexSequenceElement_unbounded, element_flags_anonymous_sequence_ComplexSequenceElement_unbounded); + { + SBound bound = 0; + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_ComplexSequenceElement_unbounded, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_ComplexSequenceElement_unbounded)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_ComplexSequenceElement_unbounded", type_ids_my_complex_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_ComplexSequenceElement_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_complex_sequence = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_complex_sequence = 0x00000002; + bool common_my_complex_sequence_ec {false}; + CommonStructMember common_my_complex_sequence {TypeObjectUtils::build_common_struct_member(member_id_my_complex_sequence, member_flags_my_complex_sequence, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_sequence, common_my_complex_sequence_ec))}; + if (!common_my_complex_sequence_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_sequence member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_complex_sequence = "my_complex_sequence"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_sequence; + ann_custom_SequenceStruct.reset(); + CompleteMemberDetail detail_my_complex_sequence = TypeObjectUtils::build_complete_member_detail(name_my_complex_sequence, member_ann_builtin_my_complex_sequence, ann_custom_SequenceStruct); + CompleteStructMember member_my_complex_sequence = TypeObjectUtils::build_complete_struct_member(common_my_complex_sequence, detail_my_complex_sequence); + TypeObjectUtils::add_complete_struct_member(member_seq_SequenceStruct, member_my_complex_sequence); + } + { + TypeIdentifierPair type_ids_my_complex_bounded_sequence; + ReturnCode_t return_code_my_complex_bounded_sequence {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_complex_bounded_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_sequence_ComplexSequenceElement_123", type_ids_my_complex_bounded_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_bounded_sequence) + { + return_code_my_complex_bounded_sequence = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ComplexSequenceElement", type_ids_my_complex_bounded_sequence); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_complex_bounded_sequence) + { + ::register_ComplexSequenceElement_type_identifier(type_ids_my_complex_bounded_sequence); + } + bool element_identifier_anonymous_sequence_ComplexSequenceElement_123_ec {false}; + TypeIdentifier* element_identifier_anonymous_sequence_ComplexSequenceElement_123 {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_bounded_sequence, element_identifier_anonymous_sequence_ComplexSequenceElement_123_ec))}; + if (!element_identifier_anonymous_sequence_ComplexSequenceElement_123_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent."); + return; + } + EquivalenceKind equiv_kind_anonymous_sequence_ComplexSequenceElement_123 = EK_COMPLETE; + if (TK_NONE == type_ids_my_complex_bounded_sequence.type_identifier2()._d()) + { + equiv_kind_anonymous_sequence_ComplexSequenceElement_123 = EK_BOTH; + } + CollectionElementFlag element_flags_anonymous_sequence_ComplexSequenceElement_123 = 0; + PlainCollectionHeader header_anonymous_sequence_ComplexSequenceElement_123 = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_ComplexSequenceElement_123, element_flags_anonymous_sequence_ComplexSequenceElement_123); + { + SBound bound = static_cast(123); + PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_ComplexSequenceElement_123, bound, + eprosima::fastcdr::external(element_identifier_anonymous_sequence_ComplexSequenceElement_123)); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_ComplexSequenceElement_123", type_ids_my_complex_bounded_sequence)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_sequence_ComplexSequenceElement_123 already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_complex_bounded_sequence = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_complex_bounded_sequence = 0x00000003; + bool common_my_complex_bounded_sequence_ec {false}; + CommonStructMember common_my_complex_bounded_sequence {TypeObjectUtils::build_common_struct_member(member_id_my_complex_bounded_sequence, member_flags_my_complex_bounded_sequence, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_bounded_sequence, common_my_complex_bounded_sequence_ec))}; + if (!common_my_complex_bounded_sequence_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_complex_bounded_sequence member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_complex_bounded_sequence = "my_complex_bounded_sequence"; + eprosima::fastcdr::optional member_ann_builtin_my_complex_bounded_sequence; + ann_custom_SequenceStruct.reset(); + CompleteMemberDetail detail_my_complex_bounded_sequence = TypeObjectUtils::build_complete_member_detail(name_my_complex_bounded_sequence, member_ann_builtin_my_complex_bounded_sequence, ann_custom_SequenceStruct); + CompleteStructMember member_my_complex_bounded_sequence = TypeObjectUtils::build_complete_struct_member(common_my_complex_bounded_sequence, detail_my_complex_bounded_sequence); + TypeObjectUtils::add_complete_struct_member(member_seq_SequenceStruct, member_my_complex_bounded_sequence); + } + CompleteStructType struct_type_SequenceStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_SequenceStruct, header_SequenceStruct, member_seq_SequenceStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_SequenceStruct, type_name_SequenceStruct.to_string(), type_ids_SequenceStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "SequenceStruct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.hpp similarity index 65% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.hpp index afa3f5f98b0..aa34019b7ea 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/basic_array_struct/basic_array_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/gen/sequence_structTypeObjectSupport.hpp @@ -13,14 +13,14 @@ // limitations under the License. /*! - * @file basic_array_structTypeObjectSupport.hpp + * @file sequence_structTypeObjectSupport.hpp * Header file containing the API required to register the TypeObject representation of the described types in the IDL file * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#ifndef FAST_DDS_GENERATED__SEQUENCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__SEQUENCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register TheOtherObjectInArray related TypeIdentifier. + * @brief Register NestedSequenceElement related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,10 +47,10 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_TheOtherObjectInArray_type_identifier( +eProsima_user_DllExport void register_NestedSequenceElement_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register basic_array_struct related TypeIdentifier. + * @brief Register ComplexSequenceElement related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,10 +59,22 @@ eProsima_user_DllExport void register_TheOtherObjectInArray_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_basic_array_struct_type_identifier( +eProsima_user_DllExport void register_ComplexSequenceElement_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register SequenceStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_SequenceStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // FAST_DDS_GENERATED__BASIC_ARRAY_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#endif // FAST_DDS_GENERATED__SEQUENCE_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl new file mode 100644 index 00000000000..9a776855590 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl @@ -0,0 +1,19 @@ +struct NestedSequenceElement +{ + string my_string; +}; + +struct ComplexSequenceElement +{ + short my_short; + long my_long; + NestedSequenceElement my_complex_element; +}; + +struct SequenceStruct +{ + sequence my_basic_sequence; + sequence my_bounded_sequence; + sequence my_complex_sequence; + sequence my_complex_bounded_sequence; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_struct.hpp similarity index 89% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_struct.hpp index 23a51572101..fb5664b8732 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_struct.hpp @@ -52,33 +52,33 @@ #endif // _WIN32 /*! - * @brief This class represents the structure string_struct defined by the user in the IDL file. + * @brief This class represents the structure StringStruct defined by the user in the IDL file. * @ingroup string_struct */ -class string_struct +class StringStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport string_struct() + eProsima_user_DllExport StringStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~string_struct() + eProsima_user_DllExport ~StringStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object string_struct that will be copied. + * @param x Reference to the object StringStruct that will be copied. */ - eProsima_user_DllExport string_struct( - const string_struct& x) + eProsima_user_DllExport StringStruct( + const StringStruct& x) { m_my_string = x.m_my_string; @@ -92,10 +92,10 @@ class string_struct /*! * @brief Move constructor. - * @param x Reference to the object string_struct that will be copied. + * @param x Reference to the object StringStruct that will be copied. */ - eProsima_user_DllExport string_struct( - string_struct&& x) noexcept + eProsima_user_DllExport StringStruct( + StringStruct&& x) noexcept { m_my_string = std::move(x.m_my_string); m_my_wstring = std::move(x.m_my_wstring); @@ -105,10 +105,10 @@ class string_struct /*! * @brief Copy assignment. - * @param x Reference to the object string_struct that will be copied. + * @param x Reference to the object StringStruct that will be copied. */ - eProsima_user_DllExport string_struct& operator =( - const string_struct& x) + eProsima_user_DllExport StringStruct& operator =( + const StringStruct& x) { m_my_string = x.m_my_string; @@ -124,10 +124,10 @@ class string_struct /*! * @brief Move assignment. - * @param x Reference to the object string_struct that will be copied. + * @param x Reference to the object StringStruct that will be copied. */ - eProsima_user_DllExport string_struct& operator =( - string_struct&& x) noexcept + eProsima_user_DllExport StringStruct& operator =( + StringStruct&& x) noexcept { m_my_string = std::move(x.m_my_string); @@ -139,10 +139,10 @@ class string_struct /*! * @brief Comparison operator. - * @param x string_struct object to compare. + * @param x StringStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const string_struct& x) const + const StringStruct& x) const { return (m_my_string == x.m_my_string && m_my_wstring == x.m_my_wstring && @@ -152,10 +152,10 @@ class string_struct /*! * @brief Comparison operator. - * @param x string_struct object to compare. + * @param x StringStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const string_struct& x) const + const StringStruct& x) const { return !(*this == x); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.hpp index c5abbd1de8c..1d5e43a5a5a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.hpp @@ -24,8 +24,8 @@ #include "string_struct.hpp" -constexpr uint32_t string_struct_max_cdr_typesize {84566UL}; -constexpr uint32_t string_struct_max_key_cdr_typesize {0UL}; +constexpr uint32_t StringStruct_max_cdr_typesize {84566UL}; +constexpr uint32_t StringStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -36,7 +36,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const string_struct& data); + const StringStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.ipp similarity index 97% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.ipp index ef03a319ea5..732a933e09a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structCdrAux.ipp @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const string_struct& data, + const StringStruct& data, size_t& current_alignment) { static_cast(data); @@ -71,7 +71,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const string_struct& data) + const StringStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -91,7 +91,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - string_struct& data) + StringStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -127,7 +127,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const string_struct& data) + const StringStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.cxx similarity index 82% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.cxx index 0a1ebdfde3d..68f1132a3dc 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -string_structPubSubType::string_structPubSubType() +StringStructPubSubType::StringStructPubSubType() { - setName("string_struct"); + setName("StringStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(string_struct::getMaxCdrSerializedSize()); + static_cast(StringStruct::getMaxCdrSerializedSize()); #else - string_struct_max_cdr_typesize; + StringStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = string_struct_max_key_cdr_typesize > 16 ? string_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = StringStruct_max_key_cdr_typesize > 16 ? StringStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -string_structPubSubType::~string_structPubSubType() +StringStructPubSubType::~StringStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ string_structPubSubType::~string_structPubSubType() } } -bool string_structPubSubType::serialize( +bool StringStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const string_struct* p_type = static_cast(data); + const StringStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool string_structPubSubType::serialize( return true; } -bool string_structPubSubType::deserialize( +bool StringStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - string_struct* p_type = static_cast(data); + StringStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool string_structPubSubType::deserialize( return true; } -std::function string_structPubSubType::getSerializedSizeProvider( +std::function StringStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function string_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function string_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function string_structPubSubType::getSerializedSizeProvider( }; } -void* string_structPubSubType::createData() +void* StringStructPubSubType::createData() { - return reinterpret_cast(new string_struct()); + return reinterpret_cast(new StringStruct()); } -void string_structPubSubType::deleteData( +void StringStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool string_structPubSubType::getKey( +bool StringStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool string_structPubSubType::getKey( return false; } - const string_struct* p_type = static_cast(data); + const StringStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - string_struct_max_key_cdr_typesize); + StringStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool string_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || string_struct_max_key_cdr_typesize > 16) + if (force_md5 || StringStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool string_structPubSubType::getKey( return true; } -void string_structPubSubType::register_type_object_representation() +void StringStructPubSubType::register_type_object_representation() { - register_string_struct_type_identifier(type_identifiers_); + register_StringStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.hpp index fbe45bbfb16..e8e375b8b10 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structPubSubTypes.hpp @@ -39,18 +39,18 @@ /*! - * @brief This class represents the TopicDataType of the type string_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type StringStruct defined by the user in the IDL file. * @ingroup string_struct */ -class string_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class StringStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef string_struct type; + typedef StringStruct type; - eProsima_user_DllExport string_structPubSubType(); + eProsima_user_DllExport StringStructPubSubType(); - eProsima_user_DllExport ~string_structPubSubType() override; + eProsima_user_DllExport ~StringStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.cxx similarity index 85% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.cxx index c0fcc4a949b..c598b5d2b0c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.cxx @@ -39,25 +39,25 @@ using namespace eprosima::fastdds::dds::xtypes; // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_string_struct_type_identifier( - TypeIdentifierPair& type_ids_string_struct) +void register_StringStruct_type_identifier( + TypeIdentifierPair& type_ids_StringStruct) { - ReturnCode_t return_code_string_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_string_struct = + ReturnCode_t return_code_StringStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_StringStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "string_struct", type_ids_string_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_string_struct) + "StringStruct", type_ids_StringStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_StringStruct) { - StructTypeFlag struct_flags_string_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_StringStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_string_struct = "string_struct"; - eprosima::fastcdr::optional type_ann_builtin_string_struct; - eprosima::fastcdr::optional ann_custom_string_struct; - CompleteTypeDetail detail_string_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_string_struct, ann_custom_string_struct, type_name_string_struct.to_string()); - CompleteStructHeader header_string_struct; - header_string_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_string_struct); - CompleteStructMemberSeq member_seq_string_struct; + QualifiedTypeName type_name_StringStruct = "StringStruct"; + eprosima::fastcdr::optional type_ann_builtin_StringStruct; + eprosima::fastcdr::optional ann_custom_StringStruct; + CompleteTypeDetail detail_StringStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_StringStruct, ann_custom_StringStruct, type_name_StringStruct.to_string()); + CompleteStructHeader header_StringStruct; + header_StringStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_StringStruct); + CompleteStructMemberSeq member_seq_StringStruct; { TypeIdentifierPair type_ids_my_string; ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; @@ -91,10 +91,10 @@ void register_string_struct_type_identifier( } MemberName name_my_string = "my_string"; eprosima::fastcdr::optional member_ann_builtin_my_string; - ann_custom_string_struct.reset(); - CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_string_struct); + ann_custom_StringStruct.reset(); + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_StringStruct); CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); - TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_StringStruct, member_my_string); } { TypeIdentifierPair type_ids_my_wstring; @@ -129,10 +129,10 @@ void register_string_struct_type_identifier( } MemberName name_my_wstring = "my_wstring"; eprosima::fastcdr::optional member_ann_builtin_my_wstring; - ann_custom_string_struct.reset(); - CompleteMemberDetail detail_my_wstring = TypeObjectUtils::build_complete_member_detail(name_my_wstring, member_ann_builtin_my_wstring, ann_custom_string_struct); + ann_custom_StringStruct.reset(); + CompleteMemberDetail detail_my_wstring = TypeObjectUtils::build_complete_member_detail(name_my_wstring, member_ann_builtin_my_wstring, ann_custom_StringStruct); CompleteStructMember member_my_wstring = TypeObjectUtils::build_complete_struct_member(common_my_wstring, detail_my_wstring); - TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_wstring); + TypeObjectUtils::add_complete_struct_member(member_seq_StringStruct, member_my_wstring); } { TypeIdentifierPair type_ids_my_bounded_string; @@ -167,10 +167,10 @@ void register_string_struct_type_identifier( } MemberName name_my_bounded_string = "my_bounded_string"; eprosima::fastcdr::optional member_ann_builtin_my_bounded_string; - ann_custom_string_struct.reset(); - CompleteMemberDetail detail_my_bounded_string = TypeObjectUtils::build_complete_member_detail(name_my_bounded_string, member_ann_builtin_my_bounded_string, ann_custom_string_struct); + ann_custom_StringStruct.reset(); + CompleteMemberDetail detail_my_bounded_string = TypeObjectUtils::build_complete_member_detail(name_my_bounded_string, member_ann_builtin_my_bounded_string, ann_custom_StringStruct); CompleteStructMember member_my_bounded_string = TypeObjectUtils::build_complete_struct_member(common_my_bounded_string, detail_my_bounded_string); - TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_bounded_string); + TypeObjectUtils::add_complete_struct_member(member_seq_StringStruct, member_my_bounded_string); } { TypeIdentifierPair type_ids_my_bounded_wstring; @@ -205,17 +205,17 @@ void register_string_struct_type_identifier( } MemberName name_my_bounded_wstring = "my_bounded_wstring"; eprosima::fastcdr::optional member_ann_builtin_my_bounded_wstring; - ann_custom_string_struct.reset(); - CompleteMemberDetail detail_my_bounded_wstring = TypeObjectUtils::build_complete_member_detail(name_my_bounded_wstring, member_ann_builtin_my_bounded_wstring, ann_custom_string_struct); + ann_custom_StringStruct.reset(); + CompleteMemberDetail detail_my_bounded_wstring = TypeObjectUtils::build_complete_member_detail(name_my_bounded_wstring, member_ann_builtin_my_bounded_wstring, ann_custom_StringStruct); CompleteStructMember member_my_bounded_wstring = TypeObjectUtils::build_complete_struct_member(common_my_bounded_wstring, detail_my_bounded_wstring); - TypeObjectUtils::add_complete_struct_member(member_seq_string_struct, member_my_bounded_wstring); + TypeObjectUtils::add_complete_struct_member(member_seq_StringStruct, member_my_bounded_wstring); } - CompleteStructType struct_type_string_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_string_struct, header_string_struct, member_seq_string_struct); + CompleteStructType struct_type_StringStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_StringStruct, header_StringStruct, member_seq_StringStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_string_struct, type_name_string_struct.to_string(), type_ids_string_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_StringStruct, type_name_StringStruct.to_string(), type_ids_StringStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "string_struct already registered in TypeObjectRegistry for a different type."); + "StringStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.hpp similarity index 94% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.hpp index ce3dac4c5ab..d62ad4c887c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/string_struct/string_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/gen/string_structTypeObjectSupport.hpp @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register string_struct related TypeIdentifier. + * @brief Register StringStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,7 +47,7 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_string_struct_type_identifier( +eProsima_user_DllExport void register_StringStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl similarity index 85% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl index 5c026cbda7d..58043c722f2 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/string_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl @@ -1,4 +1,4 @@ -struct string_struct +struct StringStruct { string my_string; wstring my_wstring; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp new file mode 100644 index 00000000000..c7d74da812a --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp @@ -0,0 +1,663 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file struct_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__STRUCT_STRUCT_HPP +#define FAST_DDS_GENERATED__STRUCT_STRUCT_HPP + +#include +#include +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(STRUCT_STRUCT_SOURCE) +#define STRUCT_STRUCT_DllAPI __declspec( dllexport ) +#else +#define STRUCT_STRUCT_DllAPI __declspec( dllimport ) +#endif // STRUCT_STRUCT_SOURCE +#else +#define STRUCT_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define STRUCT_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure GrandparentStruct defined by the user in the IDL file. + * @ingroup struct_struct + */ +class GrandparentStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport GrandparentStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~GrandparentStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object GrandparentStruct that will be copied. + */ + eProsima_user_DllExport GrandparentStruct( + const GrandparentStruct& x) + { + m_my_long = x.m_my_long; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object GrandparentStruct that will be copied. + */ + eProsima_user_DllExport GrandparentStruct( + GrandparentStruct&& x) noexcept + { + m_my_long = x.m_my_long; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object GrandparentStruct that will be copied. + */ + eProsima_user_DllExport GrandparentStruct& operator =( + const GrandparentStruct& x) + { + + m_my_long = x.m_my_long; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object GrandparentStruct that will be copied. + */ + eProsima_user_DllExport GrandparentStruct& operator =( + GrandparentStruct&& x) noexcept + { + + m_my_long = x.m_my_long; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x GrandparentStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const GrandparentStruct& x) const + { + return (m_my_long == x.m_my_long); + } + + /*! + * @brief Comparison operator. + * @param x GrandparentStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const GrandparentStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_long + * @param _my_long New value for member my_long + */ + eProsima_user_DllExport void my_long( + int32_t _my_long) + { + m_my_long = _my_long; + } + + /*! + * @brief This function returns the value of member my_long + * @return Value of member my_long + */ + eProsima_user_DllExport int32_t my_long() const + { + return m_my_long; + } + + /*! + * @brief This function returns a reference to member my_long + * @return Reference to member my_long + */ + eProsima_user_DllExport int32_t& my_long() + { + return m_my_long; + } + + + +private: + + int32_t m_my_long{0}; + +}; +/*! + * @brief This class represents the structure ParentStruct defined by the user in the IDL file. + * @ingroup struct_struct + */ +class ParentStruct : public GrandparentStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport ParentStruct() + : GrandparentStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~ParentStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object ParentStruct that will be copied. + */ + eProsima_user_DllExport ParentStruct( + const ParentStruct& x) + : GrandparentStruct(x) + { + m_my_short = x.m_my_short; + + m_my_string = x.m_my_string; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object ParentStruct that will be copied. + */ + eProsima_user_DllExport ParentStruct( + ParentStruct&& x) noexcept + : GrandparentStruct(std::move(x)) + + { + m_my_short = x.m_my_short; + m_my_string = std::move(x.m_my_string); + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object ParentStruct that will be copied. + */ + eProsima_user_DllExport ParentStruct& operator =( + const ParentStruct& x) + { + GrandparentStruct::operator =(x); + + m_my_short = x.m_my_short; + + m_my_string = x.m_my_string; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object ParentStruct that will be copied. + */ + eProsima_user_DllExport ParentStruct& operator =( + ParentStruct&& x) noexcept + { + GrandparentStruct::operator =(std::move(x)); + + m_my_short = x.m_my_short; + m_my_string = std::move(x.m_my_string); + return *this; + } + + /*! + * @brief Comparison operator. + * @param x ParentStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const ParentStruct& x) const + { + if (GrandparentStruct::operator !=(x)) + { + return false; + } + return (m_my_short == x.m_my_short && + m_my_string == x.m_my_string); + } + + /*! + * @brief Comparison operator. + * @param x ParentStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const ParentStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short + */ + eProsima_user_DllExport void my_short( + int16_t _my_short) + { + m_my_short = _my_short; + } + + /*! + * @brief This function returns the value of member my_short + * @return Value of member my_short + */ + eProsima_user_DllExport int16_t my_short() const + { + return m_my_short; + } + + /*! + * @brief This function returns a reference to member my_short + * @return Reference to member my_short + */ + eProsima_user_DllExport int16_t& my_short() + { + return m_my_short; + } + + + /*! + * @brief This function copies the value in member my_string + * @param _my_string New value to be copied in member my_string + */ + eProsima_user_DllExport void my_string( + const std::string& _my_string) + { + m_my_string = _my_string; + } + + /*! + * @brief This function moves the value in member my_string + * @param _my_string New value to be moved in member my_string + */ + eProsima_user_DllExport void my_string( + std::string&& _my_string) + { + m_my_string = std::move(_my_string); + } + + /*! + * @brief This function returns a constant reference to member my_string + * @return Constant reference to member my_string + */ + eProsima_user_DllExport const std::string& my_string() const + { + return m_my_string; + } + + /*! + * @brief This function returns a reference to member my_string + * @return Reference to member my_string + */ + eProsima_user_DllExport std::string& my_string() + { + return m_my_string; + } + + + +private: + + int16_t m_my_short{0}; + std::string m_my_string; + +}; +/*! + * @brief This class represents the structure NestedStructElement defined by the user in the IDL file. + * @ingroup struct_struct + */ +class NestedStructElement +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport NestedStructElement() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~NestedStructElement() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object NestedStructElement that will be copied. + */ + eProsima_user_DllExport NestedStructElement( + const NestedStructElement& x) + { + m_my_boolean = x.m_my_boolean; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object NestedStructElement that will be copied. + */ + eProsima_user_DllExport NestedStructElement( + NestedStructElement&& x) noexcept + { + m_my_boolean = x.m_my_boolean; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object NestedStructElement that will be copied. + */ + eProsima_user_DllExport NestedStructElement& operator =( + const NestedStructElement& x) + { + + m_my_boolean = x.m_my_boolean; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object NestedStructElement that will be copied. + */ + eProsima_user_DllExport NestedStructElement& operator =( + NestedStructElement&& x) noexcept + { + + m_my_boolean = x.m_my_boolean; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x NestedStructElement object to compare. + */ + eProsima_user_DllExport bool operator ==( + const NestedStructElement& x) const + { + return (m_my_boolean == x.m_my_boolean); + } + + /*! + * @brief Comparison operator. + * @param x NestedStructElement object to compare. + */ + eProsima_user_DllExport bool operator !=( + const NestedStructElement& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_boolean + * @param _my_boolean New value for member my_boolean + */ + eProsima_user_DllExport void my_boolean( + bool _my_boolean) + { + m_my_boolean = _my_boolean; + } + + /*! + * @brief This function returns the value of member my_boolean + * @return Value of member my_boolean + */ + eProsima_user_DllExport bool my_boolean() const + { + return m_my_boolean; + } + + /*! + * @brief This function returns a reference to member my_boolean + * @return Reference to member my_boolean + */ + eProsima_user_DllExport bool& my_boolean() + { + return m_my_boolean; + } + + + +private: + + bool m_my_boolean{false}; + +}; +/*! + * @brief This class represents the structure StructStruct defined by the user in the IDL file. + * @ingroup struct_struct + */ +class StructStruct : public ParentStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport StructStruct() + : ParentStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~StructStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object StructStruct that will be copied. + */ + eProsima_user_DllExport StructStruct( + const StructStruct& x) + : ParentStruct(x) + { + m_my_nested_element = x.m_my_nested_element; + + m_my_char = x.m_my_char; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object StructStruct that will be copied. + */ + eProsima_user_DllExport StructStruct( + StructStruct&& x) noexcept + : ParentStruct(std::move(x)) + + { + m_my_nested_element = std::move(x.m_my_nested_element); + m_my_char = x.m_my_char; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object StructStruct that will be copied. + */ + eProsima_user_DllExport StructStruct& operator =( + const StructStruct& x) + { + ParentStruct::operator =(x); + + m_my_nested_element = x.m_my_nested_element; + + m_my_char = x.m_my_char; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object StructStruct that will be copied. + */ + eProsima_user_DllExport StructStruct& operator =( + StructStruct&& x) noexcept + { + ParentStruct::operator =(std::move(x)); + + m_my_nested_element = std::move(x.m_my_nested_element); + m_my_char = x.m_my_char; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x StructStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const StructStruct& x) const + { + if (ParentStruct::operator !=(x)) + { + return false; + } + return (m_my_nested_element == x.m_my_nested_element && + m_my_char == x.m_my_char); + } + + /*! + * @brief Comparison operator. + * @param x StructStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const StructStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function copies the value in member my_nested_element + * @param _my_nested_element New value to be copied in member my_nested_element + */ + eProsima_user_DllExport void my_nested_element( + const NestedStructElement& _my_nested_element) + { + m_my_nested_element = _my_nested_element; + } + + /*! + * @brief This function moves the value in member my_nested_element + * @param _my_nested_element New value to be moved in member my_nested_element + */ + eProsima_user_DllExport void my_nested_element( + NestedStructElement&& _my_nested_element) + { + m_my_nested_element = std::move(_my_nested_element); + } + + /*! + * @brief This function returns a constant reference to member my_nested_element + * @return Constant reference to member my_nested_element + */ + eProsima_user_DllExport const NestedStructElement& my_nested_element() const + { + return m_my_nested_element; + } + + /*! + * @brief This function returns a reference to member my_nested_element + * @return Reference to member my_nested_element + */ + eProsima_user_DllExport NestedStructElement& my_nested_element() + { + return m_my_nested_element; + } + + + /*! + * @brief This function sets a value in member my_char + * @param _my_char New value for member my_char + */ + eProsima_user_DllExport void my_char( + char _my_char) + { + m_my_char = _my_char; + } + + /*! + * @brief This function returns the value of member my_char + * @return Value of member my_char + */ + eProsima_user_DllExport char my_char() const + { + return m_my_char; + } + + /*! + * @brief This function returns a reference to member my_char + * @return Reference to member my_char + */ + eProsima_user_DllExport char& my_char() + { + return m_my_char; + } + + + +private: + + NestedStructElement m_my_nested_element; + char m_my_char{0}; + +}; + +#endif // _FAST_DDS_GENERATED_STRUCT_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp similarity index 56% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp index d50851767e1..2d06ac6872a 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp @@ -13,28 +13,28 @@ // limitations under the License. /*! - * @file complex_nested_arraysCdrAux.hpp + * @file struct_structCdrAux.hpp * This source file contains some definitions of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP -#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP +#ifndef FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_HPP -#include "complex_nested_arrays.hpp" +#include "struct_struct.hpp" -constexpr uint32_t FirstLevelElement_max_cdr_typesize {296UL}; -constexpr uint32_t FirstLevelElement_max_key_cdr_typesize {0UL}; +constexpr uint32_t NestedStructElement_max_cdr_typesize {5UL}; +constexpr uint32_t NestedStructElement_max_key_cdr_typesize {0UL}; -constexpr uint32_t ThirdLevelElement_max_cdr_typesize {24UL}; -constexpr uint32_t ThirdLevelElement_max_key_cdr_typesize {0UL}; +constexpr uint32_t ParentStruct_max_cdr_typesize {272UL}; +constexpr uint32_t ParentStruct_max_key_cdr_typesize {0UL}; -constexpr uint32_t SecondLevelElement_max_cdr_typesize {56UL}; -constexpr uint32_t SecondLevelElement_max_key_cdr_typesize {0UL}; +constexpr uint32_t GrandparentStruct_max_cdr_typesize {8UL}; +constexpr uint32_t GrandparentStruct_max_key_cdr_typesize {0UL}; -constexpr uint32_t complex_nested_arrays_max_cdr_typesize {896UL}; -constexpr uint32_t complex_nested_arrays_max_key_cdr_typesize {0UL}; +constexpr uint32_t StructStruct_max_cdr_typesize {278UL}; +constexpr uint32_t StructStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -45,23 +45,23 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const ThirdLevelElement& data); + const GrandparentStruct& data); eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const SecondLevelElement& data); + const ParentStruct& data); eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const FirstLevelElement& data); + const NestedStructElement& data); eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const complex_nested_arrays& data); + const StructStruct& data); } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_HPP +#endif // FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp similarity index 77% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp index 6744f03ef0a..b87fa71512e 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp @@ -13,16 +13,16 @@ // limitations under the License. /*! - * @file complex_nested_arraysCdrAux.ipp + * @file struct_structCdrAux.ipp * This source file contains some declarations of CDR related functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP -#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP +#ifndef FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_IPP -#include "complex_nested_arraysCdrAux.hpp" +#include "struct_structCdrAux.hpp" #include #include @@ -37,7 +37,7 @@ namespace fastcdr { template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const ThirdLevelElement& data, + const GrandparentStruct& data, size_t& current_alignment) { static_cast(data); @@ -51,10 +51,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.x(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.y(), current_alignment); + data.my_long(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -65,7 +62,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const ThirdLevelElement& data) + const GrandparentStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -74,8 +71,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.x() - << eprosima::fastcdr::MemberId(1) << data.y() + << eprosima::fastcdr::MemberId(0) << data.my_long() ; scdr.end_serialize_type(current_state); } @@ -83,7 +79,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - ThirdLevelElement& data) + GrandparentStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -94,11 +90,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.x(); - break; - - case 1: - dcdr >> data.y(); + dcdr >> data.my_long(); break; default: @@ -111,7 +103,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const ThirdLevelElement& data) + const GrandparentStruct& data) { static_cast(scdr); static_cast(data); @@ -121,7 +113,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const SecondLevelElement& data, + const ParentStruct& data, size_t& current_alignment) { static_cast(data); @@ -135,10 +127,13 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.an_element_alone(), current_alignment); + data.my_long(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.a_limited_other_value(), current_alignment); + data.my_short(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_string(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -149,7 +144,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const SecondLevelElement& data) + const ParentStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -158,8 +153,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.an_element_alone() - << eprosima::fastcdr::MemberId(1) << data.a_limited_other_value() + << eprosima::fastcdr::MemberId(0) << data.my_long() + << eprosima::fastcdr::MemberId(1) << data.my_short() + << eprosima::fastcdr::MemberId(2) << data.my_string() ; scdr.end_serialize_type(current_state); } @@ -167,7 +163,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - SecondLevelElement& data) + ParentStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -178,11 +174,15 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.an_element_alone(); + dcdr >> data.my_long(); break; case 1: - dcdr >> data.a_limited_other_value(); + dcdr >> data.my_short(); + break; + + case 2: + dcdr >> data.my_string(); break; default: @@ -195,7 +195,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const SecondLevelElement& data) + const ParentStruct& data) { static_cast(scdr); static_cast(data); @@ -205,7 +205,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const FirstLevelElement& data, + const NestedStructElement& data, size_t& current_alignment) { static_cast(data); @@ -219,13 +219,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.useless_name(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), - data.sub(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.an_element_alone(), current_alignment); + data.my_boolean(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -236,7 +230,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const FirstLevelElement& data) + const NestedStructElement& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -245,9 +239,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.useless_name() - << eprosima::fastcdr::MemberId(1) << data.sub() - << eprosima::fastcdr::MemberId(2) << data.an_element_alone() + << eprosima::fastcdr::MemberId(0) << data.my_boolean() ; scdr.end_serialize_type(current_state); } @@ -255,7 +247,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - FirstLevelElement& data) + NestedStructElement& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -266,15 +258,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.useless_name(); - break; - - case 1: - dcdr >> data.sub(); - break; - - case 2: - dcdr >> data.an_element_alone(); + dcdr >> data.my_boolean(); break; default: @@ -287,7 +271,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const FirstLevelElement& data) + const NestedStructElement& data) { static_cast(scdr); static_cast(data); @@ -297,7 +281,7 @@ void serialize_key( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const complex_nested_arrays& data, + const StructStruct& data, size_t& current_alignment) { static_cast(data); @@ -311,7 +295,19 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.array_of_elements(), current_alignment); + data.my_long(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_short(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_string(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_nested_element(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.my_char(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -322,7 +318,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const complex_nested_arrays& data) + const StructStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -331,7 +327,11 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.array_of_elements() + << eprosima::fastcdr::MemberId(0) << data.my_long() + << eprosima::fastcdr::MemberId(1) << data.my_short() + << eprosima::fastcdr::MemberId(2) << data.my_string() + << eprosima::fastcdr::MemberId(3) << data.my_nested_element() + << eprosima::fastcdr::MemberId(4) << data.my_char() ; scdr.end_serialize_type(current_state); } @@ -339,7 +339,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - complex_nested_arrays& data) + StructStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -350,7 +350,23 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.array_of_elements(); + dcdr >> data.my_long(); + break; + + case 1: + dcdr >> data.my_short(); + break; + + case 2: + dcdr >> data.my_string(); + break; + + case 3: + dcdr >> data.my_nested_element(); + break; + + case 4: + dcdr >> data.my_char(); break; default: @@ -363,7 +379,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const complex_nested_arrays& data) + const StructStruct& data) { static_cast(scdr); static_cast(data); @@ -374,5 +390,5 @@ void serialize_key( } // namespace fastcdr } // namespace eprosima -#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYSCDRAUX_IPP +#endif // FAST_DDS_GENERATED__STRUCT_STRUCTCDRAUX_IPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.cxx similarity index 78% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.cxx index 25169cfa13f..90e507519ec 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.cxx @@ -13,42 +13,42 @@ // limitations under the License. /*! - * @file complex_nested_arraysPubSubTypes.cpp + * @file struct_structPubSubTypes.cpp * This header file contains the implementation of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#include "complex_nested_arraysPubSubTypes.hpp" +#include "struct_structPubSubTypes.hpp" #include #include -#include "complex_nested_arraysCdrAux.hpp" -#include "complex_nested_arraysTypeObjectSupport.hpp" +#include "struct_structCdrAux.hpp" +#include "struct_structTypeObjectSupport.hpp" using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -ThirdLevelElementPubSubType::ThirdLevelElementPubSubType() +GrandparentStructPubSubType::GrandparentStructPubSubType() { - setName("ThirdLevelElement"); + setName("GrandparentStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(ThirdLevelElement::getMaxCdrSerializedSize()); + static_cast(GrandparentStruct::getMaxCdrSerializedSize()); #else - ThirdLevelElement_max_cdr_typesize; + GrandparentStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = ThirdLevelElement_max_key_cdr_typesize > 16 ? ThirdLevelElement_max_key_cdr_typesize : 16; + uint32_t keyLength = GrandparentStruct_max_key_cdr_typesize > 16 ? GrandparentStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -ThirdLevelElementPubSubType::~ThirdLevelElementPubSubType() +GrandparentStructPubSubType::~GrandparentStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ ThirdLevelElementPubSubType::~ThirdLevelElementPubSubType() } } -bool ThirdLevelElementPubSubType::serialize( +bool GrandparentStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const ThirdLevelElement* p_type = static_cast(data); + const GrandparentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool ThirdLevelElementPubSubType::serialize( return true; } -bool ThirdLevelElementPubSubType::deserialize( +bool GrandparentStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - ThirdLevelElement* p_type = static_cast(data); + GrandparentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool ThirdLevelElementPubSubType::deserialize( return true; } -std::function ThirdLevelElementPubSubType::getSerializedSizeProvider( +std::function GrandparentStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function ThirdLevelElementPubSubType::getSerializedSizeProvider { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function ThirdLevelElementPubSubType::getSerializedSizeProvider eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function ThirdLevelElementPubSubType::getSerializedSizeProvider }; } -void* ThirdLevelElementPubSubType::createData() +void* GrandparentStructPubSubType::createData() { - return reinterpret_cast(new ThirdLevelElement()); + return reinterpret_cast(new GrandparentStruct()); } -void ThirdLevelElementPubSubType::deleteData( +void GrandparentStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool ThirdLevelElementPubSubType::getKey( +bool GrandparentStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool ThirdLevelElementPubSubType::getKey( return false; } - const ThirdLevelElement* p_type = static_cast(data); + const GrandparentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - ThirdLevelElement_max_key_cdr_typesize); + GrandparentStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool ThirdLevelElementPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || ThirdLevelElement_max_key_cdr_typesize > 16) + if (force_md5 || GrandparentStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,29 +219,29 @@ bool ThirdLevelElementPubSubType::getKey( return true; } -void ThirdLevelElementPubSubType::register_type_object_representation() +void GrandparentStructPubSubType::register_type_object_representation() { - register_ThirdLevelElement_type_identifier(type_identifiers_); + register_GrandparentStruct_type_identifier(type_identifiers_); } -SecondLevelElementPubSubType::SecondLevelElementPubSubType() +ParentStructPubSubType::ParentStructPubSubType() { - setName("SecondLevelElement"); + setName("ParentStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(SecondLevelElement::getMaxCdrSerializedSize()); + static_cast(ParentStruct::getMaxCdrSerializedSize()); #else - SecondLevelElement_max_cdr_typesize; + ParentStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = SecondLevelElement_max_key_cdr_typesize > 16 ? SecondLevelElement_max_key_cdr_typesize : 16; + uint32_t keyLength = ParentStruct_max_key_cdr_typesize > 16 ? ParentStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -SecondLevelElementPubSubType::~SecondLevelElementPubSubType() +ParentStructPubSubType::~ParentStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -249,12 +249,12 @@ SecondLevelElementPubSubType::~SecondLevelElementPubSubType() } } -bool SecondLevelElementPubSubType::serialize( +bool ParentStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const SecondLevelElement* p_type = static_cast(data); + const ParentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -291,14 +291,14 @@ bool SecondLevelElementPubSubType::serialize( return true; } -bool SecondLevelElementPubSubType::deserialize( +bool ParentStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - SecondLevelElement* p_type = static_cast(data); + ParentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -325,7 +325,7 @@ bool SecondLevelElementPubSubType::deserialize( return true; } -std::function SecondLevelElementPubSubType::getSerializedSizeProvider( +std::function ParentStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -333,7 +333,7 @@ std::function SecondLevelElementPubSubType::getSerializedSizeProvide { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -343,7 +343,7 @@ std::function SecondLevelElementPubSubType::getSerializedSizeProvide eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -354,18 +354,18 @@ std::function SecondLevelElementPubSubType::getSerializedSizeProvide }; } -void* SecondLevelElementPubSubType::createData() +void* ParentStructPubSubType::createData() { - return reinterpret_cast(new SecondLevelElement()); + return reinterpret_cast(new ParentStruct()); } -void SecondLevelElementPubSubType::deleteData( +void ParentStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool SecondLevelElementPubSubType::getKey( +bool ParentStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -375,11 +375,11 @@ bool SecondLevelElementPubSubType::getKey( return false; } - const SecondLevelElement* p_type = static_cast(data); + const ParentStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - SecondLevelElement_max_key_cdr_typesize); + ParentStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -388,7 +388,7 @@ bool SecondLevelElementPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || SecondLevelElement_max_key_cdr_typesize > 16) + if (force_md5 || ParentStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -412,29 +412,29 @@ bool SecondLevelElementPubSubType::getKey( return true; } -void SecondLevelElementPubSubType::register_type_object_representation() +void ParentStructPubSubType::register_type_object_representation() { - register_SecondLevelElement_type_identifier(type_identifiers_); + register_ParentStruct_type_identifier(type_identifiers_); } -FirstLevelElementPubSubType::FirstLevelElementPubSubType() +NestedStructElementPubSubType::NestedStructElementPubSubType() { - setName("FirstLevelElement"); + setName("NestedStructElement"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(FirstLevelElement::getMaxCdrSerializedSize()); + static_cast(NestedStructElement::getMaxCdrSerializedSize()); #else - FirstLevelElement_max_cdr_typesize; + NestedStructElement_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = FirstLevelElement_max_key_cdr_typesize > 16 ? FirstLevelElement_max_key_cdr_typesize : 16; + uint32_t keyLength = NestedStructElement_max_key_cdr_typesize > 16 ? NestedStructElement_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -FirstLevelElementPubSubType::~FirstLevelElementPubSubType() +NestedStructElementPubSubType::~NestedStructElementPubSubType() { if (m_keyBuffer != nullptr) { @@ -442,12 +442,12 @@ FirstLevelElementPubSubType::~FirstLevelElementPubSubType() } } -bool FirstLevelElementPubSubType::serialize( +bool NestedStructElementPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const FirstLevelElement* p_type = static_cast(data); + const NestedStructElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -484,14 +484,14 @@ bool FirstLevelElementPubSubType::serialize( return true; } -bool FirstLevelElementPubSubType::deserialize( +bool NestedStructElementPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - FirstLevelElement* p_type = static_cast(data); + NestedStructElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -518,7 +518,7 @@ bool FirstLevelElementPubSubType::deserialize( return true; } -std::function FirstLevelElementPubSubType::getSerializedSizeProvider( +std::function NestedStructElementPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -526,7 +526,7 @@ std::function FirstLevelElementPubSubType::getSerializedSizeProvider { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -536,7 +536,7 @@ std::function FirstLevelElementPubSubType::getSerializedSizeProvider eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -547,18 +547,18 @@ std::function FirstLevelElementPubSubType::getSerializedSizeProvider }; } -void* FirstLevelElementPubSubType::createData() +void* NestedStructElementPubSubType::createData() { - return reinterpret_cast(new FirstLevelElement()); + return reinterpret_cast(new NestedStructElement()); } -void FirstLevelElementPubSubType::deleteData( +void NestedStructElementPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool FirstLevelElementPubSubType::getKey( +bool NestedStructElementPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -568,11 +568,11 @@ bool FirstLevelElementPubSubType::getKey( return false; } - const FirstLevelElement* p_type = static_cast(data); + const NestedStructElement* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - FirstLevelElement_max_key_cdr_typesize); + NestedStructElement_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -581,7 +581,7 @@ bool FirstLevelElementPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || FirstLevelElement_max_key_cdr_typesize > 16) + if (force_md5 || NestedStructElement_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -605,29 +605,29 @@ bool FirstLevelElementPubSubType::getKey( return true; } -void FirstLevelElementPubSubType::register_type_object_representation() +void NestedStructElementPubSubType::register_type_object_representation() { - register_FirstLevelElement_type_identifier(type_identifiers_); + register_NestedStructElement_type_identifier(type_identifiers_); } -complex_nested_arraysPubSubType::complex_nested_arraysPubSubType() +StructStructPubSubType::StructStructPubSubType() { - setName("complex_nested_arrays"); + setName("StructStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(complex_nested_arrays::getMaxCdrSerializedSize()); + static_cast(StructStruct::getMaxCdrSerializedSize()); #else - complex_nested_arrays_max_cdr_typesize; + StructStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = complex_nested_arrays_max_key_cdr_typesize > 16 ? complex_nested_arrays_max_key_cdr_typesize : 16; + uint32_t keyLength = StructStruct_max_key_cdr_typesize > 16 ? StructStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -complex_nested_arraysPubSubType::~complex_nested_arraysPubSubType() +StructStructPubSubType::~StructStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -635,12 +635,12 @@ complex_nested_arraysPubSubType::~complex_nested_arraysPubSubType() } } -bool complex_nested_arraysPubSubType::serialize( +bool StructStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const complex_nested_arrays* p_type = static_cast(data); + const StructStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -677,14 +677,14 @@ bool complex_nested_arraysPubSubType::serialize( return true; } -bool complex_nested_arraysPubSubType::deserialize( +bool StructStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - complex_nested_arrays* p_type = static_cast(data); + StructStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -711,7 +711,7 @@ bool complex_nested_arraysPubSubType::deserialize( return true; } -std::function complex_nested_arraysPubSubType::getSerializedSizeProvider( +std::function StructStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -719,7 +719,7 @@ std::function complex_nested_arraysPubSubType::getSerializedSizeProv { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -729,7 +729,7 @@ std::function complex_nested_arraysPubSubType::getSerializedSizeProv eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -740,18 +740,18 @@ std::function complex_nested_arraysPubSubType::getSerializedSizeProv }; } -void* complex_nested_arraysPubSubType::createData() +void* StructStructPubSubType::createData() { - return reinterpret_cast(new complex_nested_arrays()); + return reinterpret_cast(new StructStruct()); } -void complex_nested_arraysPubSubType::deleteData( +void StructStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool complex_nested_arraysPubSubType::getKey( +bool StructStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -761,11 +761,11 @@ bool complex_nested_arraysPubSubType::getKey( return false; } - const complex_nested_arrays* p_type = static_cast(data); + const StructStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - complex_nested_arrays_max_key_cdr_typesize); + StructStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -774,7 +774,7 @@ bool complex_nested_arraysPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || complex_nested_arrays_max_key_cdr_typesize > 16) + if (force_md5 || StructStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -798,11 +798,11 @@ bool complex_nested_arraysPubSubType::getKey( return true; } -void complex_nested_arraysPubSubType::register_type_object_representation() +void StructStructPubSubType::register_type_object_representation() { - register_complex_nested_arrays_type_identifier(type_identifiers_); + register_StructStruct_type_identifier(type_identifiers_); } // Include auxiliary functions like for serializing/deserializing. -#include "complex_nested_arraysCdrAux.ipp" +#include "struct_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.hpp similarity index 84% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.hpp index 578f1555e40..5a87fd6aa30 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structPubSubTypes.hpp @@ -13,15 +13,15 @@ // limitations under the License. /*! - * @file complex_nested_arraysPubSubTypes.hpp + * @file struct_structPubSubTypes.hpp * This header file contains the declaration of the serialization functions. * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP -#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP +#ifndef FAST_DDS_GENERATED__STRUCT_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__STRUCT_STRUCT_PUBSUBTYPES_HPP #include #include @@ -29,28 +29,28 @@ #include #include -#include "complex_nested_arrays.hpp" +#include "struct_struct.hpp" #if !defined(GEN_API_VER) || (GEN_API_VER != 2) #error \ - Generated complex_nested_arrays is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. + Generated struct_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // GEN_API_VER /*! - * @brief This class represents the TopicDataType of the type ThirdLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays + * @brief This class represents the TopicDataType of the type GrandparentStruct defined by the user in the IDL file. + * @ingroup struct_struct */ -class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +class GrandparentStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef ThirdLevelElement type; + typedef GrandparentStruct type; - eProsima_user_DllExport ThirdLevelElementPubSubType(); + eProsima_user_DllExport GrandparentStructPubSubType(); - eProsima_user_DllExport ~ThirdLevelElementPubSubType() override; + eProsima_user_DllExport ~GrandparentStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -130,18 +130,18 @@ class ThirdLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type SecondLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays + * @brief This class represents the TopicDataType of the type ParentStruct defined by the user in the IDL file. + * @ingroup struct_struct */ -class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +class ParentStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef SecondLevelElement type; + typedef ParentStruct type; - eProsima_user_DllExport SecondLevelElementPubSubType(); + eProsima_user_DllExport ParentStructPubSubType(); - eProsima_user_DllExport ~SecondLevelElementPubSubType() override; + eProsima_user_DllExport ~ParentStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -185,7 +185,7 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return true; + return false; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -221,18 +221,18 @@ class SecondLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataTyp }; /*! - * @brief This class represents the TopicDataType of the type FirstLevelElement defined by the user in the IDL file. - * @ingroup complex_nested_arrays + * @brief This class represents the TopicDataType of the type NestedStructElement defined by the user in the IDL file. + * @ingroup struct_struct */ -class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType +class NestedStructElementPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef FirstLevelElement type; + typedef NestedStructElement type; - eProsima_user_DllExport FirstLevelElementPubSubType(); + eProsima_user_DllExport NestedStructElementPubSubType(); - eProsima_user_DllExport ~FirstLevelElementPubSubType() override; + eProsima_user_DllExport ~NestedStructElementPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -276,7 +276,7 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType #ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED eProsima_user_DllExport inline bool is_bounded() const override { - return false; + return true; } #endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED @@ -312,18 +312,18 @@ class FirstLevelElementPubSubType : public eprosima::fastdds::dds::TopicDataType }; /*! - * @brief This class represents the TopicDataType of the type complex_nested_arrays defined by the user in the IDL file. - * @ingroup complex_nested_arrays + * @brief This class represents the TopicDataType of the type StructStruct defined by the user in the IDL file. + * @ingroup struct_struct */ -class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicDataType +class StructStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef complex_nested_arrays type; + typedef StructStruct type; - eProsima_user_DllExport complex_nested_arraysPubSubType(); + eProsima_user_DllExport StructStructPubSubType(); - eProsima_user_DllExport ~complex_nested_arraysPubSubType() override; + eProsima_user_DllExport ~StructStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, @@ -402,5 +402,5 @@ class complex_nested_arraysPubSubType : public eprosima::fastdds::dds::TopicData }; -#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_PUBSUBTYPES_HPP +#endif // FAST_DDS_GENERATED__STRUCT_STRUCT_PUBSUBTYPES_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..cc538eecd3d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx @@ -0,0 +1,385 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file struct_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "struct_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "struct_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_GrandparentStruct_type_identifier( + TypeIdentifierPair& type_ids_GrandparentStruct) +{ + + ReturnCode_t return_code_GrandparentStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_GrandparentStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandparentStruct", type_ids_GrandparentStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrandparentStruct) + { + StructTypeFlag struct_flags_GrandparentStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_GrandparentStruct = "GrandparentStruct"; + eprosima::fastcdr::optional type_ann_builtin_GrandparentStruct; + eprosima::fastcdr::optional ann_custom_GrandparentStruct; + CompleteTypeDetail detail_GrandparentStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_GrandparentStruct, ann_custom_GrandparentStruct, type_name_GrandparentStruct.to_string()); + CompleteStructHeader header_GrandparentStruct; + header_GrandparentStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_GrandparentStruct); + CompleteStructMemberSeq member_seq_GrandparentStruct; + { + TypeIdentifierPair type_ids_my_long; + ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_long = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_long); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_long) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_long Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_long = 0x00000000; + bool common_my_long_ec {false}; + CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; + if (!common_my_long_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_long member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_long = "my_long"; + eprosima::fastcdr::optional member_ann_builtin_my_long; + ann_custom_GrandparentStruct.reset(); + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_GrandparentStruct); + CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_GrandparentStruct, member_my_long); + } + CompleteStructType struct_type_GrandparentStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_GrandparentStruct, header_GrandparentStruct, member_seq_GrandparentStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_GrandparentStruct, type_name_GrandparentStruct.to_string(), type_ids_GrandparentStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "GrandparentStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_ParentStruct_type_identifier( + TypeIdentifierPair& type_ids_ParentStruct) +{ + + ReturnCode_t return_code_ParentStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_ParentStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ParentStruct", type_ids_ParentStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_ParentStruct) + { + StructTypeFlag struct_flags_ParentStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_ParentStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandparentStruct", type_ids_ParentStruct); + + if (return_code_ParentStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_GrandparentStruct_type_identifier(type_ids_ParentStruct); + } + QualifiedTypeName type_name_ParentStruct = "ParentStruct"; + eprosima::fastcdr::optional type_ann_builtin_ParentStruct; + eprosima::fastcdr::optional ann_custom_ParentStruct; + CompleteTypeDetail detail_ParentStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ParentStruct, ann_custom_ParentStruct, type_name_ParentStruct.to_string()); + CompleteStructHeader header_ParentStruct; + if (EK_COMPLETE == type_ids_ParentStruct.type_identifier1()._d()) + { + header_ParentStruct = TypeObjectUtils::build_complete_struct_header(type_ids_ParentStruct.type_identifier1(), detail_ParentStruct); + } + else if (EK_COMPLETE == type_ids_ParentStruct.type_identifier2()._d()) + { + header_ParentStruct = TypeObjectUtils::build_complete_struct_header(type_ids_ParentStruct.type_identifier2(), detail_ParentStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ParentStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_ParentStruct; + { + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_my_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_short Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_short = 0x00000001; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; + ann_custom_ParentStruct.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_ParentStruct); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_ParentStruct, member_my_short); + } + { + TypeIdentifierPair type_ids_my_string; + ReturnCode_t return_code_my_string {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_string = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "anonymous_string_unbounded", type_ids_my_string); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_string) + { + { + SBound bound = 0; + StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn, + "anonymous_string_unbounded", type_ids_my_string)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type."); + } + } + } + StructMemberFlag member_flags_my_string = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_string = 0x00000002; + bool common_my_string_ec {false}; + CommonStructMember common_my_string {TypeObjectUtils::build_common_struct_member(member_id_my_string, member_flags_my_string, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_string, common_my_string_ec))}; + if (!common_my_string_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_string member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_string = "my_string"; + eprosima::fastcdr::optional member_ann_builtin_my_string; + ann_custom_ParentStruct.reset(); + CompleteMemberDetail detail_my_string = TypeObjectUtils::build_complete_member_detail(name_my_string, member_ann_builtin_my_string, ann_custom_ParentStruct); + CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); + TypeObjectUtils::add_complete_struct_member(member_seq_ParentStruct, member_my_string); + } + CompleteStructType struct_type_ParentStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ParentStruct, header_ParentStruct, member_seq_ParentStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_ParentStruct, type_name_ParentStruct.to_string(), type_ids_ParentStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "ParentStruct already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_NestedStructElement_type_identifier( + TypeIdentifierPair& type_ids_NestedStructElement) +{ + + ReturnCode_t return_code_NestedStructElement {eprosima::fastdds::dds::RETCODE_OK}; + return_code_NestedStructElement = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedStructElement", type_ids_NestedStructElement); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_NestedStructElement) + { + StructTypeFlag struct_flags_NestedStructElement = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_NestedStructElement = "NestedStructElement"; + eprosima::fastcdr::optional type_ann_builtin_NestedStructElement; + eprosima::fastcdr::optional ann_custom_NestedStructElement; + CompleteTypeDetail detail_NestedStructElement = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_NestedStructElement, ann_custom_NestedStructElement, type_name_NestedStructElement.to_string()); + CompleteStructHeader header_NestedStructElement; + header_NestedStructElement = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_NestedStructElement); + CompleteStructMemberSeq member_seq_NestedStructElement; + { + TypeIdentifierPair type_ids_my_boolean; + ReturnCode_t return_code_my_boolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_boolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_my_boolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_boolean) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_boolean Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_boolean = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_boolean = 0x00000000; + bool common_my_boolean_ec {false}; + CommonStructMember common_my_boolean {TypeObjectUtils::build_common_struct_member(member_id_my_boolean, member_flags_my_boolean, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_boolean, common_my_boolean_ec))}; + if (!common_my_boolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_boolean member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_boolean = "my_boolean"; + eprosima::fastcdr::optional member_ann_builtin_my_boolean; + ann_custom_NestedStructElement.reset(); + CompleteMemberDetail detail_my_boolean = TypeObjectUtils::build_complete_member_detail(name_my_boolean, member_ann_builtin_my_boolean, ann_custom_NestedStructElement); + CompleteStructMember member_my_boolean = TypeObjectUtils::build_complete_struct_member(common_my_boolean, detail_my_boolean); + TypeObjectUtils::add_complete_struct_member(member_seq_NestedStructElement, member_my_boolean); + } + CompleteStructType struct_type_NestedStructElement = TypeObjectUtils::build_complete_struct_type(struct_flags_NestedStructElement, header_NestedStructElement, member_seq_NestedStructElement); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_NestedStructElement, type_name_NestedStructElement.to_string(), type_ids_NestedStructElement)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "NestedStructElement already registered in TypeObjectRegistry for a different type."); + } + } +} +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_StructStruct_type_identifier( + TypeIdentifierPair& type_ids_StructStruct) +{ + + ReturnCode_t return_code_StructStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_StructStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "StructStruct", type_ids_StructStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_StructStruct) + { + StructTypeFlag struct_flags_StructStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + return_code_StructStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "ParentStruct", type_ids_StructStruct); + + if (return_code_StructStruct != eprosima::fastdds::dds::RETCODE_OK) + { +::register_ParentStruct_type_identifier(type_ids_StructStruct); + } + QualifiedTypeName type_name_StructStruct = "StructStruct"; + eprosima::fastcdr::optional type_ann_builtin_StructStruct; + eprosima::fastcdr::optional ann_custom_StructStruct; + CompleteTypeDetail detail_StructStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_StructStruct, ann_custom_StructStruct, type_name_StructStruct.to_string()); + CompleteStructHeader header_StructStruct; + if (EK_COMPLETE == type_ids_StructStruct.type_identifier1()._d()) + { + header_StructStruct = TypeObjectUtils::build_complete_struct_header(type_ids_StructStruct.type_identifier1(), detail_StructStruct); + } + else if (EK_COMPLETE == type_ids_StructStruct.type_identifier2()._d()) + { + header_StructStruct = TypeObjectUtils::build_complete_struct_header(type_ids_StructStruct.type_identifier2(), detail_StructStruct); + } + else + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "StructStruct Structure: base_type TypeIdentifier registered in TypeObjectRegistry is inconsistent."); + return; + } + CompleteStructMemberSeq member_seq_StructStruct; + { + TypeIdentifierPair type_ids_my_nested_element; + ReturnCode_t return_code_my_nested_element {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_nested_element = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "NestedStructElement", type_ids_my_nested_element); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_nested_element) + { + ::register_NestedStructElement_type_identifier(type_ids_my_nested_element); + } + StructMemberFlag member_flags_my_nested_element = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_nested_element = 0x00000003; + bool common_my_nested_element_ec {false}; + CommonStructMember common_my_nested_element {TypeObjectUtils::build_common_struct_member(member_id_my_nested_element, member_flags_my_nested_element, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_nested_element, common_my_nested_element_ec))}; + if (!common_my_nested_element_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_nested_element member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_nested_element = "my_nested_element"; + eprosima::fastcdr::optional member_ann_builtin_my_nested_element; + ann_custom_StructStruct.reset(); + CompleteMemberDetail detail_my_nested_element = TypeObjectUtils::build_complete_member_detail(name_my_nested_element, member_ann_builtin_my_nested_element, ann_custom_StructStruct); + CompleteStructMember member_my_nested_element = TypeObjectUtils::build_complete_struct_member(common_my_nested_element, detail_my_nested_element); + TypeObjectUtils::add_complete_struct_member(member_seq_StructStruct, member_my_nested_element); + } + { + TypeIdentifierPair type_ids_my_char; + ReturnCode_t return_code_my_char {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_char = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_char", type_ids_my_char); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_char) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_char Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_char = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_char = 0x00000004; + bool common_my_char_ec {false}; + CommonStructMember common_my_char {TypeObjectUtils::build_common_struct_member(member_id_my_char, member_flags_my_char, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_char, common_my_char_ec))}; + if (!common_my_char_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_char member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_char = "my_char"; + eprosima::fastcdr::optional member_ann_builtin_my_char; + ann_custom_StructStruct.reset(); + CompleteMemberDetail detail_my_char = TypeObjectUtils::build_complete_member_detail(name_my_char, member_ann_builtin_my_char, ann_custom_StructStruct); + CompleteStructMember member_my_char = TypeObjectUtils::build_complete_struct_member(common_my_char, detail_my_char); + TypeObjectUtils::add_complete_struct_member(member_seq_StructStruct, member_my_char); + } + CompleteStructType struct_type_StructStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_StructStruct, header_StructStruct, member_seq_StructStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_StructStruct, type_name_StructStruct.to_string(), type_ids_StructStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "StructStruct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.hpp similarity index 80% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.hpp index aec5bb21e0a..b7f57b7fe3d 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/complex_nested_arrays/complex_nested_arraysTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.hpp @@ -13,14 +13,14 @@ // limitations under the License. /*! - * @file complex_nested_arraysTypeObjectSupport.hpp + * @file struct_structTypeObjectSupport.hpp * Header file containing the API required to register the TypeObject representation of the described types in the IDL file * * This file was generated by the tool fastddsgen. */ -#ifndef FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP -#define FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP +#ifndef FAST_DDS_GENERATED__STRUCT_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__STRUCT_STRUCT_TYPE_OBJECT_SUPPORT_HPP #include @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register ThirdLevelElement related TypeIdentifier. + * @brief Register GrandparentStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,10 +47,10 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_ThirdLevelElement_type_identifier( +eProsima_user_DllExport void register_GrandparentStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register SecondLevelElement related TypeIdentifier. + * @brief Register ParentStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -59,10 +59,10 @@ eProsima_user_DllExport void register_ThirdLevelElement_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_SecondLevelElement_type_identifier( +eProsima_user_DllExport void register_ParentStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register FirstLevelElement related TypeIdentifier. + * @brief Register NestedStructElement related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -71,10 +71,10 @@ eProsima_user_DllExport void register_SecondLevelElement_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_FirstLevelElement_type_identifier( +eProsima_user_DllExport void register_NestedStructElement_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register complex_nested_arrays related TypeIdentifier. + * @brief Register StructStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -83,10 +83,10 @@ eProsima_user_DllExport void register_FirstLevelElement_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_complex_nested_arrays_type_identifier( +eProsima_user_DllExport void register_StructStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC -#endif // FAST_DDS_GENERATED__COMPLEX_NESTED_ARRAYS_TYPE_OBJECT_SUPPORT_HPP +#endif // FAST_DDS_GENERATED__STRUCT_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl new file mode 100644 index 00000000000..b5c0a7ffe36 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl @@ -0,0 +1,21 @@ +struct GrandparentStruct +{ + long my_long; +}; + +struct ParentStruct : GrandparentStruct +{ + short my_short; + string my_string; +}; + +struct NestedStructElement +{ + boolean my_boolean; +}; + +struct StructStruct : ParentStruct +{ + NestedStructElement my_nested_element; + char my_char; +}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp similarity index 89% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp index a71b1d67661..9301bd069c7 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp @@ -755,61 +755,56 @@ class ComplexUnion std::function member_destructor_; }; /*! - * @brief This class represents the structure union_struct defined by the user in the IDL file. + * @brief This class represents the structure UnionStruct defined by the user in the IDL file. * @ingroup union_struct */ -class union_struct +class UnionStruct { public: /*! * @brief Default constructor. */ - eProsima_user_DllExport union_struct() + eProsima_user_DllExport UnionStruct() { } /*! * @brief Default destructor. */ - eProsima_user_DllExport ~union_struct() + eProsima_user_DllExport ~UnionStruct() { } /*! * @brief Copy constructor. - * @param x Reference to the object union_struct that will be copied. + * @param x Reference to the object UnionStruct that will be copied. */ - eProsima_user_DllExport union_struct( - const union_struct& x) + eProsima_user_DllExport UnionStruct( + const UnionStruct& x) { - m_my_basic_union = x.m_my_basic_union; - m_my_complex_union = x.m_my_complex_union; } /*! * @brief Move constructor. - * @param x Reference to the object union_struct that will be copied. + * @param x Reference to the object UnionStruct that will be copied. */ - eProsima_user_DllExport union_struct( - union_struct&& x) noexcept + eProsima_user_DllExport UnionStruct( + UnionStruct&& x) noexcept { - m_my_basic_union = std::move(x.m_my_basic_union); m_my_complex_union = std::move(x.m_my_complex_union); } /*! * @brief Copy assignment. - * @param x Reference to the object union_struct that will be copied. + * @param x Reference to the object UnionStruct that will be copied. */ - eProsima_user_DllExport union_struct& operator =( - const union_struct& x) + eProsima_user_DllExport UnionStruct& operator =( + const UnionStruct& x) { - m_my_basic_union = x.m_my_basic_union; - m_my_complex_union = x.m_my_complex_union; return *this; @@ -817,77 +812,36 @@ class union_struct /*! * @brief Move assignment. - * @param x Reference to the object union_struct that will be copied. + * @param x Reference to the object UnionStruct that will be copied. */ - eProsima_user_DllExport union_struct& operator =( - union_struct&& x) noexcept + eProsima_user_DllExport UnionStruct& operator =( + UnionStruct&& x) noexcept { - m_my_basic_union = std::move(x.m_my_basic_union); m_my_complex_union = std::move(x.m_my_complex_union); return *this; } /*! * @brief Comparison operator. - * @param x union_struct object to compare. + * @param x UnionStruct object to compare. */ eProsima_user_DllExport bool operator ==( - const union_struct& x) const + const UnionStruct& x) const { - return (m_my_basic_union == x.m_my_basic_union && - m_my_complex_union == x.m_my_complex_union); + return (m_my_complex_union == x.m_my_complex_union); } /*! * @brief Comparison operator. - * @param x union_struct object to compare. + * @param x UnionStruct object to compare. */ eProsima_user_DllExport bool operator !=( - const union_struct& x) const + const UnionStruct& x) const { return !(*this == x); } - /*! - * @brief This function copies the value in member my_basic_union - * @param _my_basic_union New value to be copied in member my_basic_union - */ - eProsima_user_DllExport void my_basic_union( - const BasicUnion& _my_basic_union) - { - m_my_basic_union = _my_basic_union; - } - - /*! - * @brief This function moves the value in member my_basic_union - * @param _my_basic_union New value to be moved in member my_basic_union - */ - eProsima_user_DllExport void my_basic_union( - BasicUnion&& _my_basic_union) - { - m_my_basic_union = std::move(_my_basic_union); - } - - /*! - * @brief This function returns a constant reference to member my_basic_union - * @return Constant reference to member my_basic_union - */ - eProsima_user_DllExport const BasicUnion& my_basic_union() const - { - return m_my_basic_union; - } - - /*! - * @brief This function returns a reference to member my_basic_union - * @return Reference to member my_basic_union - */ - eProsima_user_DllExport BasicUnion& my_basic_union() - { - return m_my_basic_union; - } - - /*! * @brief This function copies the value in member my_complex_union * @param _my_complex_union New value to be copied in member my_complex_union @@ -930,7 +884,6 @@ class union_struct private: - BasicUnion m_my_basic_union; ComplexUnion m_my_complex_union; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.hpp similarity index 88% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.hpp index 1e08a5cf875..8f0a33c4712 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.hpp @@ -24,9 +24,8 @@ #include "union_struct.hpp" -constexpr uint32_t union_struct_max_cdr_typesize {548UL}; -constexpr uint32_t union_struct_max_key_cdr_typesize {0UL}; - +constexpr uint32_t UnionStruct_max_cdr_typesize {280UL}; +constexpr uint32_t UnionStruct_max_key_cdr_typesize {0UL}; namespace eprosima { @@ -37,7 +36,7 @@ class CdrSizeCalculator; eProsima_user_DllExport void serialize_key( eprosima::fastcdr::Cdr& scdr, - const union_struct& data); + const UnionStruct& data); } // namespace fastcdr diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.ipp similarity index 95% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.ipp index 608ce5915cf..61102777754 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structCdrAux.ipp @@ -287,7 +287,7 @@ eProsima_user_DllExport void deserialize( template<> eProsima_user_DllExport size_t calculate_serialized_size( eprosima::fastcdr::CdrSizeCalculator& calculator, - const union_struct& data, + const UnionStruct& data, size_t& current_alignment) { static_cast(data); @@ -301,9 +301,6 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.my_basic_union(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.my_complex_union(), current_alignment); @@ -315,7 +312,7 @@ eProsima_user_DllExport size_t calculate_serialized_size( template<> eProsima_user_DllExport void serialize( eprosima::fastcdr::Cdr& scdr, - const union_struct& data) + const UnionStruct& data) { eprosima::fastcdr::Cdr::state current_state(scdr); scdr.begin_serialize_type(current_state, @@ -324,8 +321,7 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.my_basic_union() - << eprosima::fastcdr::MemberId(1) << data.my_complex_union() + << eprosima::fastcdr::MemberId(0) << data.my_complex_union() ; scdr.end_serialize_type(current_state); } @@ -333,7 +329,7 @@ eProsima_user_DllExport void serialize( template<> eProsima_user_DllExport void deserialize( eprosima::fastcdr::Cdr& cdr, - union_struct& data) + UnionStruct& data) { cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : @@ -344,10 +340,6 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.my_basic_union(); - break; - - case 1: dcdr >> data.my_complex_union(); break; @@ -361,7 +353,7 @@ eProsima_user_DllExport void deserialize( void serialize_key( eprosima::fastcdr::Cdr& scdr, - const union_struct& data) + const UnionStruct& data) { static_cast(scdr); static_cast(data); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.cxx similarity index 83% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.cxx index 7a2ddc63316..22ad76ec79b 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.cxx @@ -31,24 +31,24 @@ using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; -union_structPubSubType::union_structPubSubType() +UnionStructPubSubType::UnionStructPubSubType() { - setName("union_struct"); + setName("UnionStruct"); uint32_t type_size = #if FASTCDR_VERSION_MAJOR == 1 - static_cast(union_struct::getMaxCdrSerializedSize()); + static_cast(UnionStruct::getMaxCdrSerializedSize()); #else - union_struct_max_cdr_typesize; + UnionStruct_max_cdr_typesize; #endif type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ m_typeSize = type_size + 4; /*encapsulation*/ m_isGetKeyDefined = false; - uint32_t keyLength = union_struct_max_key_cdr_typesize > 16 ? union_struct_max_key_cdr_typesize : 16; + uint32_t keyLength = UnionStruct_max_key_cdr_typesize > 16 ? UnionStruct_max_key_cdr_typesize : 16; m_keyBuffer = reinterpret_cast(malloc(keyLength)); memset(m_keyBuffer, 0, keyLength); } -union_structPubSubType::~union_structPubSubType() +UnionStructPubSubType::~UnionStructPubSubType() { if (m_keyBuffer != nullptr) { @@ -56,12 +56,12 @@ union_structPubSubType::~union_structPubSubType() } } -bool union_structPubSubType::serialize( +bool UnionStructPubSubType::serialize( const void* const data, SerializedPayload_t* payload, DataRepresentationId_t data_representation) { - const union_struct* p_type = static_cast(data); + const UnionStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); @@ -98,14 +98,14 @@ bool union_structPubSubType::serialize( return true; } -bool union_structPubSubType::deserialize( +bool UnionStructPubSubType::deserialize( SerializedPayload_t* payload, void* data) { try { // Convert DATA to pointer of your type - union_struct* p_type = static_cast(data); + UnionStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); @@ -132,7 +132,7 @@ bool union_structPubSubType::deserialize( return true; } -std::function union_structPubSubType::getSerializedSizeProvider( +std::function UnionStructPubSubType::getSerializedSizeProvider( const void* const data, DataRepresentationId_t data_representation) { @@ -140,7 +140,7 @@ std::function union_structPubSubType::getSerializedSizeProvider( { #if FASTCDR_VERSION_MAJOR == 1 static_cast(data_representation); - return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + 4u /*encapsulation*/; #else try @@ -150,7 +150,7 @@ std::function union_structPubSubType::getSerializedSizeProvider( eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); size_t current_alignment {0}; return static_cast(calculator.calculate_serialized_size( - *static_cast(data), current_alignment)) + + *static_cast(data), current_alignment)) + 4u /*encapsulation*/; } catch (eprosima::fastcdr::exception::Exception& /*exception*/) @@ -161,18 +161,18 @@ std::function union_structPubSubType::getSerializedSizeProvider( }; } -void* union_structPubSubType::createData() +void* UnionStructPubSubType::createData() { - return reinterpret_cast(new union_struct()); + return reinterpret_cast(new UnionStruct()); } -void union_structPubSubType::deleteData( +void UnionStructPubSubType::deleteData( void* data) { - delete(reinterpret_cast(data)); + delete(reinterpret_cast(data)); } -bool union_structPubSubType::getKey( +bool UnionStructPubSubType::getKey( const void* const data, InstanceHandle_t* handle, bool force_md5) @@ -182,11 +182,11 @@ bool union_structPubSubType::getKey( return false; } - const union_struct* p_type = static_cast(data); + const UnionStruct* p_type = static_cast(data); // Object that manages the raw buffer. eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), - union_struct_max_key_cdr_typesize); + UnionStruct_max_key_cdr_typesize); // Object that serializes the data. eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); @@ -195,7 +195,7 @@ bool union_structPubSubType::getKey( #else eprosima::fastcdr::serialize_key(ser, *p_type); #endif // FASTCDR_VERSION_MAJOR == 1 - if (force_md5 || union_struct_max_key_cdr_typesize > 16) + if (force_md5 || UnionStruct_max_key_cdr_typesize > 16) { m_md5.init(); #if FASTCDR_VERSION_MAJOR == 1 @@ -219,9 +219,9 @@ bool union_structPubSubType::getKey( return true; } -void union_structPubSubType::register_type_object_representation() +void UnionStructPubSubType::register_type_object_representation() { - register_union_struct_type_identifier(type_identifiers_); + register_UnionStruct_type_identifier(type_identifiers_); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.hpp similarity index 92% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.hpp index 29fdef4c231..bbd1b9e3986 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structPubSubTypes.hpp @@ -39,18 +39,18 @@ /*! - * @brief This class represents the TopicDataType of the type union_struct defined by the user in the IDL file. + * @brief This class represents the TopicDataType of the type UnionStruct defined by the user in the IDL file. * @ingroup union_struct */ -class union_structPubSubType : public eprosima::fastdds::dds::TopicDataType +class UnionStructPubSubType : public eprosima::fastdds::dds::TopicDataType { public: - typedef union_struct type; + typedef UnionStruct type; - eProsima_user_DllExport union_structPubSubType(); + eProsima_user_DllExport UnionStructPubSubType(); - eProsima_user_DllExport ~union_structPubSubType() override; + eProsima_user_DllExport ~UnionStructPubSubType() override; eProsima_user_DllExport bool serialize( const void* const data, diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.cxx similarity index 84% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.cxx index 7046d46eb0f..7ec28283a60 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.cxx @@ -291,53 +291,25 @@ void register_ComplexUnion_type_identifier( } } // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method -void register_union_struct_type_identifier( - TypeIdentifierPair& type_ids_union_struct) +void register_UnionStruct_type_identifier( + TypeIdentifierPair& type_ids_UnionStruct) { - ReturnCode_t return_code_union_struct {eprosima::fastdds::dds::RETCODE_OK}; - return_code_union_struct = + ReturnCode_t return_code_UnionStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_UnionStruct = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "union_struct", type_ids_union_struct); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_union_struct) + "UnionStruct", type_ids_UnionStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_UnionStruct) { - StructTypeFlag struct_flags_union_struct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + StructTypeFlag struct_flags_UnionStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, false, false); - QualifiedTypeName type_name_union_struct = "union_struct"; - eprosima::fastcdr::optional type_ann_builtin_union_struct; - eprosima::fastcdr::optional ann_custom_union_struct; - CompleteTypeDetail detail_union_struct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_union_struct, ann_custom_union_struct, type_name_union_struct.to_string()); - CompleteStructHeader header_union_struct; - header_union_struct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_union_struct); - CompleteStructMemberSeq member_seq_union_struct; - { - TypeIdentifierPair type_ids_my_basic_union; - ReturnCode_t return_code_my_basic_union {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_basic_union = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "BasicUnion", type_ids_my_basic_union); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_basic_union) - { - ::register_BasicUnion_type_identifier(type_ids_my_basic_union); - } - StructMemberFlag member_flags_my_basic_union = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_my_basic_union = 0x00000000; - bool common_my_basic_union_ec {false}; - CommonStructMember common_my_basic_union {TypeObjectUtils::build_common_struct_member(member_id_my_basic_union, member_flags_my_basic_union, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_basic_union, common_my_basic_union_ec))}; - if (!common_my_basic_union_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_basic_union member TypeIdentifier inconsistent."); - return; - } - MemberName name_my_basic_union = "my_basic_union"; - eprosima::fastcdr::optional member_ann_builtin_my_basic_union; - ann_custom_union_struct.reset(); - CompleteMemberDetail detail_my_basic_union = TypeObjectUtils::build_complete_member_detail(name_my_basic_union, member_ann_builtin_my_basic_union, ann_custom_union_struct); - CompleteStructMember member_my_basic_union = TypeObjectUtils::build_complete_struct_member(common_my_basic_union, detail_my_basic_union); - TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_my_basic_union); - } + QualifiedTypeName type_name_UnionStruct = "UnionStruct"; + eprosima::fastcdr::optional type_ann_builtin_UnionStruct; + eprosima::fastcdr::optional ann_custom_UnionStruct; + CompleteTypeDetail detail_UnionStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_UnionStruct, ann_custom_UnionStruct, type_name_UnionStruct.to_string()); + CompleteStructHeader header_UnionStruct; + header_UnionStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_UnionStruct); + CompleteStructMemberSeq member_seq_UnionStruct; { TypeIdentifierPair type_ids_my_complex_union; ReturnCode_t return_code_my_complex_union {eprosima::fastdds::dds::RETCODE_OK}; @@ -351,7 +323,7 @@ void register_union_struct_type_identifier( } StructMemberFlag member_flags_my_complex_union = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_complex_union = 0x00000001; + MemberId member_id_my_complex_union = 0x00000000; bool common_my_complex_union_ec {false}; CommonStructMember common_my_complex_union {TypeObjectUtils::build_common_struct_member(member_id_my_complex_union, member_flags_my_complex_union, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_complex_union, common_my_complex_union_ec))}; if (!common_my_complex_union_ec) @@ -361,17 +333,17 @@ void register_union_struct_type_identifier( } MemberName name_my_complex_union = "my_complex_union"; eprosima::fastcdr::optional member_ann_builtin_my_complex_union; - ann_custom_union_struct.reset(); - CompleteMemberDetail detail_my_complex_union = TypeObjectUtils::build_complete_member_detail(name_my_complex_union, member_ann_builtin_my_complex_union, ann_custom_union_struct); + ann_custom_UnionStruct.reset(); + CompleteMemberDetail detail_my_complex_union = TypeObjectUtils::build_complete_member_detail(name_my_complex_union, member_ann_builtin_my_complex_union, ann_custom_UnionStruct); CompleteStructMember member_my_complex_union = TypeObjectUtils::build_complete_struct_member(common_my_complex_union, detail_my_complex_union); - TypeObjectUtils::add_complete_struct_member(member_seq_union_struct, member_my_complex_union); + TypeObjectUtils::add_complete_struct_member(member_seq_UnionStruct, member_my_complex_union); } - CompleteStructType struct_type_union_struct = TypeObjectUtils::build_complete_struct_type(struct_flags_union_struct, header_union_struct, member_seq_union_struct); + CompleteStructType struct_type_UnionStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_UnionStruct, header_UnionStruct, member_seq_UnionStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_struct_type_object(struct_type_union_struct, type_name_union_struct.to_string(), type_ids_union_struct)) + TypeObjectUtils::build_and_register_struct_type_object(struct_type_UnionStruct, type_name_UnionStruct.to_string(), type_ids_UnionStruct)) { EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "union_struct already registered in TypeObjectRegistry for a different type."); + "UnionStruct already registered in TypeObjectRegistry for a different type."); } } } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.hpp similarity index 96% rename from test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.hpp index 506e964366b..aad34849a6f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/gen/union_struct/union_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_structTypeObjectSupport.hpp @@ -62,7 +62,7 @@ eProsima_user_DllExport void register_BasicUnion_type_identifier( eProsima_user_DllExport void register_ComplexUnion_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register union_struct related TypeIdentifier. + * @brief Register UnionStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -71,7 +71,7 @@ eProsima_user_DllExport void register_ComplexUnion_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_union_struct_type_identifier( +eProsima_user_DllExport void register_UnionStruct_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl similarity index 84% rename from test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl rename to test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl index 100bfedded1..d2d6bbefff6 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/idls/union_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl @@ -16,8 +16,7 @@ union ComplexUnion switch (long) BasicUnion fourth; }; -struct union_struct +struct UnionStruct { - BasicUnion my_basic_union; ComplexUnion my_complex_union; }; From a27a0c74c40a5e05358b680a4c80d12a8ccca949 Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 8 Jul 2024 08:37:32 +0200 Subject: [PATCH 39/52] Review - Primitives test Signed-off-by: tempate --- .../serializers/idl/dynamic_type_idl.cpp | 4 +- .../dds/xtypes/serializers/idl/CMakeLists.txt | 4 + .../serializers/idl/types/all_types.hpp | 10 + .../gen/primitives_struct.hpp | 696 ++++++++++++++++++ .../gen/primitives_structCdrAux.hpp | 46 ++ .../gen/primitives_structCdrAux.ipp | 230 ++++++ .../gen/primitives_structPubSubTypes.cxx | 229 ++++++ .../gen/primitives_structPubSubTypes.hpp | 133 ++++ .../primitives_structTypeObjectSupport.cxx | 520 +++++++++++++ .../primitives_structTypeObjectSupport.hpp | 56 ++ .../primitives_struct/primitives_struct.idl | 18 + 11 files changed, 1944 insertions(+), 2 deletions(-) create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_struct.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.ipp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.cxx create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.hpp create mode 100644 test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index 434ff344031..db81f436855 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -235,7 +235,7 @@ ReturnCode_t type_kind_to_idl( } case TK_INT8: { - idl << "char"; + idl << "int8"; break; } case TK_INT16: @@ -255,7 +255,7 @@ ReturnCode_t type_kind_to_idl( } case TK_UINT8: { - idl << "unsigned char"; + idl << "uint8"; break; } case TK_UINT16: diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index e0ec77e3e15..0923e57dd72 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -44,6 +44,10 @@ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/map_struct/map_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/map_struct/map_struct.idl COPYONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/types/primitives_struct/primitives_struct.idl + ${CMAKE_CURRENT_BINARY_DIR}/types/primitives_struct/primitives_struct.idl + COPYONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/types/sequence_struct/sequence_struct.idl ${CMAKE_CURRENT_BINARY_DIR}/types/sequence_struct/sequence_struct.idl diff --git a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp index 520c3b6b1cc..8875b72f195 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp @@ -44,6 +44,9 @@ #include "map_struct/gen/map_struct.hpp" #include "map_struct/gen/map_structPubSubTypes.hpp" +#include "primitives_struct/gen/primitives_struct.hpp" +#include "primitives_struct/gen/primitives_structPubSubTypes.hpp" + #include "sequence_struct/gen/sequence_struct.hpp" #include "sequence_struct/gen/sequence_structPubSubTypes.hpp" @@ -68,6 +71,7 @@ const std::string ENUM_STRUCT{"enum_struct"}; const std::string EXTENSIBILITY_STRUCT{"extensibility_struct"}; const std::string KEY_STRUCT{"key_struct"}; const std::string MAP_STRUCT{"map_struct"}; +const std::string PRIMITIVE_STRUCT{"primitives_struct"}; const std::string SEQUENCE_STRUCT{"sequence_struct"}; const std::string STRING_STRUCT{"string_struct"}; const std::string STRUCT_STRUCT{"struct_struct"}; @@ -84,6 +88,7 @@ const std::vector supported_types = { SupportedTypes::EXTENSIBILITY_STRUCT, SupportedTypes::KEY_STRUCT, SupportedTypes::MAP_STRUCT, + SupportedTypes::PRIMITIVE_STRUCT, SupportedTypes::SEQUENCE_STRUCT, SupportedTypes::STRING_STRUCT, SupportedTypes::STRUCT_STRUCT, @@ -135,6 +140,11 @@ void register_type_object_representation( TypeSupport type_map_struct(new MapStructPubSubType()); type_map_struct->register_type_object_representation(); } + else if (type_name == SupportedTypes::PRIMITIVE_STRUCT) + { + TypeSupport type_primitives_struct(new PrimitivesStructPubSubType()); + type_primitives_struct->register_type_object_representation(); + } else if (type_name == SupportedTypes::SEQUENCE_STRUCT) { TypeSupport type_sequence_struct(new SequenceStructPubSubType()); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_struct.hpp new file mode 100644 index 00000000000..1b3f51f6b68 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_struct.hpp @@ -0,0 +1,696 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_struct.hpp + * This header file contains the declaration of the described types in the IDL file. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__PRIMITIVES_STRUCT_HPP +#define FAST_DDS_GENERATED__PRIMITIVES_STRUCT_HPP + +#include +#include + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#if defined(PRIMITIVES_STRUCT_SOURCE) +#define PRIMITIVES_STRUCT_DllAPI __declspec( dllexport ) +#else +#define PRIMITIVES_STRUCT_DllAPI __declspec( dllimport ) +#endif // PRIMITIVES_STRUCT_SOURCE +#else +#define PRIMITIVES_STRUCT_DllAPI +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define PRIMITIVES_STRUCT_DllAPI +#endif // _WIN32 + +/*! + * @brief This class represents the structure PrimitivesStruct defined by the user in the IDL file. + * @ingroup primitives_struct + */ +class PrimitivesStruct +{ +public: + + /*! + * @brief Default constructor. + */ + eProsima_user_DllExport PrimitivesStruct() + { + } + + /*! + * @brief Default destructor. + */ + eProsima_user_DllExport ~PrimitivesStruct() + { + } + + /*! + * @brief Copy constructor. + * @param x Reference to the object PrimitivesStruct that will be copied. + */ + eProsima_user_DllExport PrimitivesStruct( + const PrimitivesStruct& x) + { + m_my_bool = x.m_my_bool; + + m_my_octet = x.m_my_octet; + + m_my_char = x.m_my_char; + + m_my_wchar = x.m_my_wchar; + + m_my_long = x.m_my_long; + + m_my_ulong = x.m_my_ulong; + + m_my_int8 = x.m_my_int8; + + m_my_uint8 = x.m_my_uint8; + + m_my_short = x.m_my_short; + + m_my_ushort = x.m_my_ushort; + + m_my_longlong = x.m_my_longlong; + + m_my_ulonglong = x.m_my_ulonglong; + + m_my_float = x.m_my_float; + + m_my_double = x.m_my_double; + + m_my_longdouble = x.m_my_longdouble; + + } + + /*! + * @brief Move constructor. + * @param x Reference to the object PrimitivesStruct that will be copied. + */ + eProsima_user_DllExport PrimitivesStruct( + PrimitivesStruct&& x) noexcept + { + m_my_bool = x.m_my_bool; + m_my_octet = x.m_my_octet; + m_my_char = x.m_my_char; + m_my_wchar = x.m_my_wchar; + m_my_long = x.m_my_long; + m_my_ulong = x.m_my_ulong; + m_my_int8 = x.m_my_int8; + m_my_uint8 = x.m_my_uint8; + m_my_short = x.m_my_short; + m_my_ushort = x.m_my_ushort; + m_my_longlong = x.m_my_longlong; + m_my_ulonglong = x.m_my_ulonglong; + m_my_float = x.m_my_float; + m_my_double = x.m_my_double; + m_my_longdouble = x.m_my_longdouble; + } + + /*! + * @brief Copy assignment. + * @param x Reference to the object PrimitivesStruct that will be copied. + */ + eProsima_user_DllExport PrimitivesStruct& operator =( + const PrimitivesStruct& x) + { + + m_my_bool = x.m_my_bool; + + m_my_octet = x.m_my_octet; + + m_my_char = x.m_my_char; + + m_my_wchar = x.m_my_wchar; + + m_my_long = x.m_my_long; + + m_my_ulong = x.m_my_ulong; + + m_my_int8 = x.m_my_int8; + + m_my_uint8 = x.m_my_uint8; + + m_my_short = x.m_my_short; + + m_my_ushort = x.m_my_ushort; + + m_my_longlong = x.m_my_longlong; + + m_my_ulonglong = x.m_my_ulonglong; + + m_my_float = x.m_my_float; + + m_my_double = x.m_my_double; + + m_my_longdouble = x.m_my_longdouble; + + return *this; + } + + /*! + * @brief Move assignment. + * @param x Reference to the object PrimitivesStruct that will be copied. + */ + eProsima_user_DllExport PrimitivesStruct& operator =( + PrimitivesStruct&& x) noexcept + { + + m_my_bool = x.m_my_bool; + m_my_octet = x.m_my_octet; + m_my_char = x.m_my_char; + m_my_wchar = x.m_my_wchar; + m_my_long = x.m_my_long; + m_my_ulong = x.m_my_ulong; + m_my_int8 = x.m_my_int8; + m_my_uint8 = x.m_my_uint8; + m_my_short = x.m_my_short; + m_my_ushort = x.m_my_ushort; + m_my_longlong = x.m_my_longlong; + m_my_ulonglong = x.m_my_ulonglong; + m_my_float = x.m_my_float; + m_my_double = x.m_my_double; + m_my_longdouble = x.m_my_longdouble; + return *this; + } + + /*! + * @brief Comparison operator. + * @param x PrimitivesStruct object to compare. + */ + eProsima_user_DllExport bool operator ==( + const PrimitivesStruct& x) const + { + return (m_my_bool == x.m_my_bool && + m_my_octet == x.m_my_octet && + m_my_char == x.m_my_char && + m_my_wchar == x.m_my_wchar && + m_my_long == x.m_my_long && + m_my_ulong == x.m_my_ulong && + m_my_int8 == x.m_my_int8 && + m_my_uint8 == x.m_my_uint8 && + m_my_short == x.m_my_short && + m_my_ushort == x.m_my_ushort && + m_my_longlong == x.m_my_longlong && + m_my_ulonglong == x.m_my_ulonglong && + m_my_float == x.m_my_float && + m_my_double == x.m_my_double && + m_my_longdouble == x.m_my_longdouble); + } + + /*! + * @brief Comparison operator. + * @param x PrimitivesStruct object to compare. + */ + eProsima_user_DllExport bool operator !=( + const PrimitivesStruct& x) const + { + return !(*this == x); + } + + /*! + * @brief This function sets a value in member my_bool + * @param _my_bool New value for member my_bool + */ + eProsima_user_DllExport void my_bool( + bool _my_bool) + { + m_my_bool = _my_bool; + } + + /*! + * @brief This function returns the value of member my_bool + * @return Value of member my_bool + */ + eProsima_user_DllExport bool my_bool() const + { + return m_my_bool; + } + + /*! + * @brief This function returns a reference to member my_bool + * @return Reference to member my_bool + */ + eProsima_user_DllExport bool& my_bool() + { + return m_my_bool; + } + + + /*! + * @brief This function sets a value in member my_octet + * @param _my_octet New value for member my_octet + */ + eProsima_user_DllExport void my_octet( + uint8_t _my_octet) + { + m_my_octet = _my_octet; + } + + /*! + * @brief This function returns the value of member my_octet + * @return Value of member my_octet + */ + eProsima_user_DllExport uint8_t my_octet() const + { + return m_my_octet; + } + + /*! + * @brief This function returns a reference to member my_octet + * @return Reference to member my_octet + */ + eProsima_user_DllExport uint8_t& my_octet() + { + return m_my_octet; + } + + + /*! + * @brief This function sets a value in member my_char + * @param _my_char New value for member my_char + */ + eProsima_user_DllExport void my_char( + char _my_char) + { + m_my_char = _my_char; + } + + /*! + * @brief This function returns the value of member my_char + * @return Value of member my_char + */ + eProsima_user_DllExport char my_char() const + { + return m_my_char; + } + + /*! + * @brief This function returns a reference to member my_char + * @return Reference to member my_char + */ + eProsima_user_DllExport char& my_char() + { + return m_my_char; + } + + + /*! + * @brief This function sets a value in member my_wchar + * @param _my_wchar New value for member my_wchar + */ + eProsima_user_DllExport void my_wchar( + wchar_t _my_wchar) + { + m_my_wchar = _my_wchar; + } + + /*! + * @brief This function returns the value of member my_wchar + * @return Value of member my_wchar + */ + eProsima_user_DllExport wchar_t my_wchar() const + { + return m_my_wchar; + } + + /*! + * @brief This function returns a reference to member my_wchar + * @return Reference to member my_wchar + */ + eProsima_user_DllExport wchar_t& my_wchar() + { + return m_my_wchar; + } + + + /*! + * @brief This function sets a value in member my_long + * @param _my_long New value for member my_long + */ + eProsima_user_DllExport void my_long( + int32_t _my_long) + { + m_my_long = _my_long; + } + + /*! + * @brief This function returns the value of member my_long + * @return Value of member my_long + */ + eProsima_user_DllExport int32_t my_long() const + { + return m_my_long; + } + + /*! + * @brief This function returns a reference to member my_long + * @return Reference to member my_long + */ + eProsima_user_DllExport int32_t& my_long() + { + return m_my_long; + } + + + /*! + * @brief This function sets a value in member my_ulong + * @param _my_ulong New value for member my_ulong + */ + eProsima_user_DllExport void my_ulong( + uint32_t _my_ulong) + { + m_my_ulong = _my_ulong; + } + + /*! + * @brief This function returns the value of member my_ulong + * @return Value of member my_ulong + */ + eProsima_user_DllExport uint32_t my_ulong() const + { + return m_my_ulong; + } + + /*! + * @brief This function returns a reference to member my_ulong + * @return Reference to member my_ulong + */ + eProsima_user_DllExport uint32_t& my_ulong() + { + return m_my_ulong; + } + + + /*! + * @brief This function sets a value in member my_int8 + * @param _my_int8 New value for member my_int8 + */ + eProsima_user_DllExport void my_int8( + int8_t _my_int8) + { + m_my_int8 = _my_int8; + } + + /*! + * @brief This function returns the value of member my_int8 + * @return Value of member my_int8 + */ + eProsima_user_DllExport int8_t my_int8() const + { + return m_my_int8; + } + + /*! + * @brief This function returns a reference to member my_int8 + * @return Reference to member my_int8 + */ + eProsima_user_DllExport int8_t& my_int8() + { + return m_my_int8; + } + + + /*! + * @brief This function sets a value in member my_uint8 + * @param _my_uint8 New value for member my_uint8 + */ + eProsima_user_DllExport void my_uint8( + uint8_t _my_uint8) + { + m_my_uint8 = _my_uint8; + } + + /*! + * @brief This function returns the value of member my_uint8 + * @return Value of member my_uint8 + */ + eProsima_user_DllExport uint8_t my_uint8() const + { + return m_my_uint8; + } + + /*! + * @brief This function returns a reference to member my_uint8 + * @return Reference to member my_uint8 + */ + eProsima_user_DllExport uint8_t& my_uint8() + { + return m_my_uint8; + } + + + /*! + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short + */ + eProsima_user_DllExport void my_short( + int16_t _my_short) + { + m_my_short = _my_short; + } + + /*! + * @brief This function returns the value of member my_short + * @return Value of member my_short + */ + eProsima_user_DllExport int16_t my_short() const + { + return m_my_short; + } + + /*! + * @brief This function returns a reference to member my_short + * @return Reference to member my_short + */ + eProsima_user_DllExport int16_t& my_short() + { + return m_my_short; + } + + + /*! + * @brief This function sets a value in member my_ushort + * @param _my_ushort New value for member my_ushort + */ + eProsima_user_DllExport void my_ushort( + uint16_t _my_ushort) + { + m_my_ushort = _my_ushort; + } + + /*! + * @brief This function returns the value of member my_ushort + * @return Value of member my_ushort + */ + eProsima_user_DllExport uint16_t my_ushort() const + { + return m_my_ushort; + } + + /*! + * @brief This function returns a reference to member my_ushort + * @return Reference to member my_ushort + */ + eProsima_user_DllExport uint16_t& my_ushort() + { + return m_my_ushort; + } + + + /*! + * @brief This function sets a value in member my_longlong + * @param _my_longlong New value for member my_longlong + */ + eProsima_user_DllExport void my_longlong( + int64_t _my_longlong) + { + m_my_longlong = _my_longlong; + } + + /*! + * @brief This function returns the value of member my_longlong + * @return Value of member my_longlong + */ + eProsima_user_DllExport int64_t my_longlong() const + { + return m_my_longlong; + } + + /*! + * @brief This function returns a reference to member my_longlong + * @return Reference to member my_longlong + */ + eProsima_user_DllExport int64_t& my_longlong() + { + return m_my_longlong; + } + + + /*! + * @brief This function sets a value in member my_ulonglong + * @param _my_ulonglong New value for member my_ulonglong + */ + eProsima_user_DllExport void my_ulonglong( + uint64_t _my_ulonglong) + { + m_my_ulonglong = _my_ulonglong; + } + + /*! + * @brief This function returns the value of member my_ulonglong + * @return Value of member my_ulonglong + */ + eProsima_user_DllExport uint64_t my_ulonglong() const + { + return m_my_ulonglong; + } + + /*! + * @brief This function returns a reference to member my_ulonglong + * @return Reference to member my_ulonglong + */ + eProsima_user_DllExport uint64_t& my_ulonglong() + { + return m_my_ulonglong; + } + + + /*! + * @brief This function sets a value in member my_float + * @param _my_float New value for member my_float + */ + eProsima_user_DllExport void my_float( + float _my_float) + { + m_my_float = _my_float; + } + + /*! + * @brief This function returns the value of member my_float + * @return Value of member my_float + */ + eProsima_user_DllExport float my_float() const + { + return m_my_float; + } + + /*! + * @brief This function returns a reference to member my_float + * @return Reference to member my_float + */ + eProsima_user_DllExport float& my_float() + { + return m_my_float; + } + + + /*! + * @brief This function sets a value in member my_double + * @param _my_double New value for member my_double + */ + eProsima_user_DllExport void my_double( + double _my_double) + { + m_my_double = _my_double; + } + + /*! + * @brief This function returns the value of member my_double + * @return Value of member my_double + */ + eProsima_user_DllExport double my_double() const + { + return m_my_double; + } + + /*! + * @brief This function returns a reference to member my_double + * @return Reference to member my_double + */ + eProsima_user_DllExport double& my_double() + { + return m_my_double; + } + + + /*! + * @brief This function sets a value in member my_longdouble + * @param _my_longdouble New value for member my_longdouble + */ + eProsima_user_DllExport void my_longdouble( + long double _my_longdouble) + { + m_my_longdouble = _my_longdouble; + } + + /*! + * @brief This function returns the value of member my_longdouble + * @return Value of member my_longdouble + */ + eProsima_user_DllExport long double my_longdouble() const + { + return m_my_longdouble; + } + + /*! + * @brief This function returns a reference to member my_longdouble + * @return Reference to member my_longdouble + */ + eProsima_user_DllExport long double& my_longdouble() + { + return m_my_longdouble; + } + + + +private: + + bool m_my_bool{false}; + uint8_t m_my_octet{0}; + char m_my_char{0}; + wchar_t m_my_wchar{0}; + int32_t m_my_long{0}; + uint32_t m_my_ulong{0}; + int8_t m_my_int8{0}; + uint8_t m_my_uint8{0}; + int16_t m_my_short{0}; + uint16_t m_my_ushort{0}; + int64_t m_my_longlong{0}; + uint64_t m_my_ulonglong{0}; + float m_my_float{0.0}; + double m_my_double{0.0}; + long double m_my_longdouble{0.0}; + +}; + +#endif // _FAST_DDS_GENERATED_PRIMITIVES_STRUCT_HPP_ + + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.hpp new file mode 100644 index 00000000000..db4d8cb0b8d --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.hpp @@ -0,0 +1,46 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structCdrAux.hpp + * This source file contains some definitions of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_HPP +#define FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_HPP + +#include "primitives_struct.hpp" + +constexpr uint32_t PrimitivesStruct_max_cdr_typesize {80UL}; +constexpr uint32_t PrimitivesStruct_max_key_cdr_typesize {0UL}; + + +namespace eprosima { +namespace fastcdr { + +class Cdr; +class CdrSizeCalculator; + +eProsima_user_DllExport void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const PrimitivesStruct& data); + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.ipp new file mode 100644 index 00000000000..3e15e487d00 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structCdrAux.ipp @@ -0,0 +1,230 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structCdrAux.ipp + * This source file contains some declarations of CDR related functions. + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_IPP +#define FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_IPP + +#include "primitives_structCdrAux.hpp" + +#include +#include + + +#include +using namespace eprosima::fastcdr::exception; + +namespace eprosima { +namespace fastcdr { + +template<> +eProsima_user_DllExport size_t calculate_serialized_size( + eprosima::fastcdr::CdrSizeCalculator& calculator, + const PrimitivesStruct& data, + size_t& current_alignment) +{ + static_cast(data); + + eprosima::fastcdr::EncodingAlgorithmFlag previous_encoding = calculator.get_encoding(); + size_t calculated_size {calculator.begin_calculate_type_serialized_size( + eprosima::fastcdr::CdrVersion::XCDRv2 == calculator.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + current_alignment)}; + + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), + data.my_bool(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_octet(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_char(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_wchar(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.my_long(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5), + data.my_ulong(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(6), + data.my_int8(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(7), + data.my_uint8(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(8), + data.my_short(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(9), + data.my_ushort(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(10), + data.my_longlong(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(11), + data.my_ulonglong(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(12), + data.my_float(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(13), + data.my_double(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(14), + data.my_longdouble(), current_alignment); + + + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); + + return calculated_size; +} + +template<> +eProsima_user_DllExport void serialize( + eprosima::fastcdr::Cdr& scdr, + const PrimitivesStruct& data) +{ + eprosima::fastcdr::Cdr::state current_state(scdr); + scdr.begin_serialize_type(current_state, + eprosima::fastcdr::CdrVersion::XCDRv2 == scdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); + + scdr + << eprosima::fastcdr::MemberId(0) << data.my_bool() + << eprosima::fastcdr::MemberId(1) << data.my_octet() + << eprosima::fastcdr::MemberId(2) << data.my_char() + << eprosima::fastcdr::MemberId(3) << data.my_wchar() + << eprosima::fastcdr::MemberId(4) << data.my_long() + << eprosima::fastcdr::MemberId(5) << data.my_ulong() + << eprosima::fastcdr::MemberId(6) << data.my_int8() + << eprosima::fastcdr::MemberId(7) << data.my_uint8() + << eprosima::fastcdr::MemberId(8) << data.my_short() + << eprosima::fastcdr::MemberId(9) << data.my_ushort() + << eprosima::fastcdr::MemberId(10) << data.my_longlong() + << eprosima::fastcdr::MemberId(11) << data.my_ulonglong() + << eprosima::fastcdr::MemberId(12) << data.my_float() + << eprosima::fastcdr::MemberId(13) << data.my_double() + << eprosima::fastcdr::MemberId(14) << data.my_longdouble() +; + scdr.end_serialize_type(current_state); +} + +template<> +eProsima_user_DllExport void deserialize( + eprosima::fastcdr::Cdr& cdr, + PrimitivesStruct& data) +{ + cdr.deserialize_type(eprosima::fastcdr::CdrVersion::XCDRv2 == cdr.get_cdr_version() ? + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2 : + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR, + [&data](eprosima::fastcdr::Cdr& dcdr, const eprosima::fastcdr::MemberId& mid) -> bool + { + bool ret_value = true; + switch (mid.id) + { + case 0: + dcdr >> data.my_bool(); + break; + + case 1: + dcdr >> data.my_octet(); + break; + + case 2: + dcdr >> data.my_char(); + break; + + case 3: + dcdr >> data.my_wchar(); + break; + + case 4: + dcdr >> data.my_long(); + break; + + case 5: + dcdr >> data.my_ulong(); + break; + + case 6: + dcdr >> data.my_int8(); + break; + + case 7: + dcdr >> data.my_uint8(); + break; + + case 8: + dcdr >> data.my_short(); + break; + + case 9: + dcdr >> data.my_ushort(); + break; + + case 10: + dcdr >> data.my_longlong(); + break; + + case 11: + dcdr >> data.my_ulonglong(); + break; + + case 12: + dcdr >> data.my_float(); + break; + + case 13: + dcdr >> data.my_double(); + break; + + case 14: + dcdr >> data.my_longdouble(); + break; + + default: + ret_value = false; + break; + } + return ret_value; + }); +} + +void serialize_key( + eprosima::fastcdr::Cdr& scdr, + const PrimitivesStruct& data) +{ + static_cast(scdr); + static_cast(data); +} + + + +} // namespace fastcdr +} // namespace eprosima + +#endif // FAST_DDS_GENERATED__PRIMITIVES_STRUCTCDRAUX_IPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.cxx b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.cxx new file mode 100644 index 00000000000..3434ba975ca --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.cxx @@ -0,0 +1,229 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structPubSubTypes.cpp + * This header file contains the implementation of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + +#include "primitives_structPubSubTypes.hpp" + +#include +#include + +#include "primitives_structCdrAux.hpp" +#include "primitives_structTypeObjectSupport.hpp" + +using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t; +using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t; +using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t; + +PrimitivesStructPubSubType::PrimitivesStructPubSubType() +{ + setName("PrimitivesStruct"); + uint32_t type_size = +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(PrimitivesStruct::getMaxCdrSerializedSize()); +#else + PrimitivesStruct_max_cdr_typesize; +#endif + type_size += static_cast(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */ + m_typeSize = type_size + 4; /*encapsulation*/ + m_isGetKeyDefined = false; + uint32_t keyLength = PrimitivesStruct_max_key_cdr_typesize > 16 ? PrimitivesStruct_max_key_cdr_typesize : 16; + m_keyBuffer = reinterpret_cast(malloc(keyLength)); + memset(m_keyBuffer, 0, keyLength); +} + +PrimitivesStructPubSubType::~PrimitivesStructPubSubType() +{ + if (m_keyBuffer != nullptr) + { + free(m_keyBuffer); + } +} + +bool PrimitivesStructPubSubType::serialize( + const void* const data, + SerializedPayload_t* payload, + DataRepresentationId_t data_representation) +{ + const PrimitivesStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->max_size); + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN, + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2); + payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; +#if FASTCDR_VERSION_MAJOR > 1 + ser.set_encoding_flag( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR : + eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2); +#endif // FASTCDR_VERSION_MAJOR > 1 + + try + { + // Serialize encapsulation + ser.serialize_encapsulation(); + // Serialize the object. + ser << *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + // Get the serialized length +#if FASTCDR_VERSION_MAJOR == 1 + payload->length = static_cast(ser.getSerializedDataLength()); +#else + payload->length = static_cast(ser.get_serialized_data_length()); +#endif // FASTCDR_VERSION_MAJOR == 1 + return true; +} + +bool PrimitivesStructPubSubType::deserialize( + SerializedPayload_t* payload, + void* data) +{ + try + { + // Convert DATA to pointer of your type + PrimitivesStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(payload->data), payload->length); + + // Object that deserializes the data. + eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN +#if FASTCDR_VERSION_MAJOR == 1 + , eprosima::fastcdr::Cdr::CdrType::DDS_CDR +#endif // FASTCDR_VERSION_MAJOR == 1 + ); + + // Deserialize encapsulation. + deser.read_encapsulation(); + payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE; + + // Deserialize the object. + deser >> *p_type; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return false; + } + + return true; +} + +std::function PrimitivesStructPubSubType::getSerializedSizeProvider( + const void* const data, + DataRepresentationId_t data_representation) +{ + return [data, data_representation]() -> uint32_t + { +#if FASTCDR_VERSION_MAJOR == 1 + static_cast(data_representation); + return static_cast(type::getCdrSerializedSize(*static_cast(data))) + + 4u /*encapsulation*/; +#else + try + { + eprosima::fastcdr::CdrSizeCalculator calculator( + data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ? + eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2); + size_t current_alignment {0}; + return static_cast(calculator.calculate_serialized_size( + *static_cast(data), current_alignment)) + + 4u /*encapsulation*/; + } + catch (eprosima::fastcdr::exception::Exception& /*exception*/) + { + return 0; + } +#endif // FASTCDR_VERSION_MAJOR == 1 + }; +} + +void* PrimitivesStructPubSubType::createData() +{ + return reinterpret_cast(new PrimitivesStruct()); +} + +void PrimitivesStructPubSubType::deleteData( + void* data) +{ + delete(reinterpret_cast(data)); +} + +bool PrimitivesStructPubSubType::getKey( + const void* const data, + InstanceHandle_t* handle, + bool force_md5) +{ + if (!m_isGetKeyDefined) + { + return false; + } + + const PrimitivesStruct* p_type = static_cast(data); + + // Object that manages the raw buffer. + eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast(m_keyBuffer), + PrimitivesStruct_max_key_cdr_typesize); + + // Object that serializes the data. + eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv1); +#if FASTCDR_VERSION_MAJOR == 1 + p_type->serializeKey(ser); +#else + eprosima::fastcdr::serialize_key(ser, *p_type); +#endif // FASTCDR_VERSION_MAJOR == 1 + if (force_md5 || PrimitivesStruct_max_key_cdr_typesize > 16) + { + m_md5.init(); +#if FASTCDR_VERSION_MAJOR == 1 + m_md5.update(m_keyBuffer, static_cast(ser.getSerializedDataLength())); +#else + m_md5.update(m_keyBuffer, static_cast(ser.get_serialized_data_length())); +#endif // FASTCDR_VERSION_MAJOR == 1 + m_md5.finalize(); + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_md5.digest[i]; + } + } + else + { + for (uint8_t i = 0; i < 16; ++i) + { + handle->value[i] = m_keyBuffer[i]; + } + } + return true; +} + +void PrimitivesStructPubSubType::register_type_object_representation() +{ + register_PrimitivesStruct_type_identifier(type_identifiers_); +} + + +// Include auxiliary functions like for serializing/deserializing. +#include "primitives_structCdrAux.ipp" diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.hpp new file mode 100644 index 00000000000..afcc3758609 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structPubSubTypes.hpp @@ -0,0 +1,133 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structPubSubTypes.hpp + * This header file contains the declaration of the serialization functions. + * + * This file was generated by the tool fastddsgen. + */ + + +#ifndef FAST_DDS_GENERATED__PRIMITIVES_STRUCT_PUBSUBTYPES_HPP +#define FAST_DDS_GENERATED__PRIMITIVES_STRUCT_PUBSUBTYPES_HPP + +#include +#include +#include +#include +#include + +#include "primitives_struct.hpp" + + +#if !defined(GEN_API_VER) || (GEN_API_VER != 2) +#error \ + Generated primitives_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. +#endif // GEN_API_VER + + +/*! + * @brief This class represents the TopicDataType of the type PrimitivesStruct defined by the user in the IDL file. + * @ingroup primitives_struct + */ +class PrimitivesStructPubSubType : public eprosima::fastdds::dds::TopicDataType +{ +public: + + typedef PrimitivesStruct type; + + eProsima_user_DllExport PrimitivesStructPubSubType(); + + eProsima_user_DllExport ~PrimitivesStructPubSubType() override; + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload) override + { + return serialize(data, payload, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport bool serialize( + const void* const data, + eprosima::fastdds::rtps::SerializedPayload_t* payload, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool deserialize( + eprosima::fastdds::rtps::SerializedPayload_t* payload, + void* data) override; + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data) override + { + return getSerializedSizeProvider(data, eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION); + } + + eProsima_user_DllExport std::function getSerializedSizeProvider( + const void* const data, + eprosima::fastdds::dds::DataRepresentationId_t data_representation) override; + + eProsima_user_DllExport bool getKey( + const void* const data, + eprosima::fastdds::rtps::InstanceHandle_t* ihandle, + bool force_md5 = false) override; + + eProsima_user_DllExport void* createData() override; + + eProsima_user_DllExport void deleteData( + void* data) override; + + //Register TypeObject representation in Fast DDS TypeObjectRegistry + eProsima_user_DllExport void register_type_object_representation() override; + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + eProsima_user_DllExport inline bool is_bounded() const override + { + return true; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_BOUNDED + +#ifdef TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + eProsima_user_DllExport inline bool is_plain() const override + { + return false; + } + + eProsima_user_DllExport inline bool is_plain( + eprosima::fastdds::dds::DataRepresentationId_t data_representation) const override + { + static_cast(data_representation); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_IS_PLAIN + +#ifdef TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + eProsima_user_DllExport inline bool construct_sample( + void* memory) const override + { + static_cast(memory); + return false; + } + +#endif // TOPIC_DATA_TYPE_API_HAS_CONSTRUCT_SAMPLE + + eprosima::fastdds::MD5 m_md5; + unsigned char* m_keyBuffer; + +}; + +#endif // FAST_DDS_GENERATED__PRIMITIVES_STRUCT_PUBSUBTYPES_HPP + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.cxx new file mode 100644 index 00000000000..dbafd4778da --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.cxx @@ -0,0 +1,520 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structTypeObjectSupport.cxx + * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#include "primitives_structTypeObjectSupport.hpp" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "primitives_struct.hpp" + + +using namespace eprosima::fastdds::dds::xtypes; + +// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method +void register_PrimitivesStruct_type_identifier( + TypeIdentifierPair& type_ids_PrimitivesStruct) +{ + + ReturnCode_t return_code_PrimitivesStruct {eprosima::fastdds::dds::RETCODE_OK}; + return_code_PrimitivesStruct = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "PrimitivesStruct", type_ids_PrimitivesStruct); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_PrimitivesStruct) + { + StructTypeFlag struct_flags_PrimitivesStruct = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE, + false, false); + QualifiedTypeName type_name_PrimitivesStruct = "PrimitivesStruct"; + eprosima::fastcdr::optional type_ann_builtin_PrimitivesStruct; + eprosima::fastcdr::optional ann_custom_PrimitivesStruct; + CompleteTypeDetail detail_PrimitivesStruct = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_PrimitivesStruct, ann_custom_PrimitivesStruct, type_name_PrimitivesStruct.to_string()); + CompleteStructHeader header_PrimitivesStruct; + header_PrimitivesStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_PrimitivesStruct); + CompleteStructMemberSeq member_seq_PrimitivesStruct; + { + TypeIdentifierPair type_ids_my_bool; + ReturnCode_t return_code_my_bool {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_bool = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_my_bool); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_bool) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_bool Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_bool = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_bool = 0x00000000; + bool common_my_bool_ec {false}; + CommonStructMember common_my_bool {TypeObjectUtils::build_common_struct_member(member_id_my_bool, member_flags_my_bool, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_bool, common_my_bool_ec))}; + if (!common_my_bool_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_bool member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_bool = "my_bool"; + eprosima::fastcdr::optional member_ann_builtin_my_bool; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_bool = TypeObjectUtils::build_complete_member_detail(name_my_bool, member_ann_builtin_my_bool, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_bool = TypeObjectUtils::build_complete_struct_member(common_my_bool, detail_my_bool); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_bool); + } + { + TypeIdentifierPair type_ids_my_octet; + ReturnCode_t return_code_my_octet {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_octet = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_byte", type_ids_my_octet); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_octet) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_octet Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_octet = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_octet = 0x00000001; + bool common_my_octet_ec {false}; + CommonStructMember common_my_octet {TypeObjectUtils::build_common_struct_member(member_id_my_octet, member_flags_my_octet, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_octet, common_my_octet_ec))}; + if (!common_my_octet_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_octet member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_octet = "my_octet"; + eprosima::fastcdr::optional member_ann_builtin_my_octet; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_octet = TypeObjectUtils::build_complete_member_detail(name_my_octet, member_ann_builtin_my_octet, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_octet = TypeObjectUtils::build_complete_struct_member(common_my_octet, detail_my_octet); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_octet); + } + { + TypeIdentifierPair type_ids_my_char; + ReturnCode_t return_code_my_char {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_char = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_char", type_ids_my_char); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_char) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_char Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_char = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_char = 0x00000002; + bool common_my_char_ec {false}; + CommonStructMember common_my_char {TypeObjectUtils::build_common_struct_member(member_id_my_char, member_flags_my_char, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_char, common_my_char_ec))}; + if (!common_my_char_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_char member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_char = "my_char"; + eprosima::fastcdr::optional member_ann_builtin_my_char; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_char = TypeObjectUtils::build_complete_member_detail(name_my_char, member_ann_builtin_my_char, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_char = TypeObjectUtils::build_complete_struct_member(common_my_char, detail_my_char); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_char); + } + { + TypeIdentifierPair type_ids_my_wchar; + ReturnCode_t return_code_my_wchar {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_wchar = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_wchar_t", type_ids_my_wchar); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_wchar) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_wchar Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_wchar = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_wchar = 0x00000003; + bool common_my_wchar_ec {false}; + CommonStructMember common_my_wchar {TypeObjectUtils::build_common_struct_member(member_id_my_wchar, member_flags_my_wchar, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_wchar, common_my_wchar_ec))}; + if (!common_my_wchar_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_wchar member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_wchar = "my_wchar"; + eprosima::fastcdr::optional member_ann_builtin_my_wchar; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_wchar = TypeObjectUtils::build_complete_member_detail(name_my_wchar, member_ann_builtin_my_wchar, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_wchar = TypeObjectUtils::build_complete_struct_member(common_my_wchar, detail_my_wchar); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_wchar); + } + { + TypeIdentifierPair type_ids_my_long; + ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_long = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int32_t", type_ids_my_long); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_long) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_long Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_long = 0x00000004; + bool common_my_long_ec {false}; + CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; + if (!common_my_long_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_long member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_long = "my_long"; + eprosima::fastcdr::optional member_ann_builtin_my_long; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_long = TypeObjectUtils::build_complete_member_detail(name_my_long, member_ann_builtin_my_long, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_long = TypeObjectUtils::build_complete_struct_member(common_my_long, detail_my_long); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_long); + } + { + TypeIdentifierPair type_ids_my_ulong; + ReturnCode_t return_code_my_ulong {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_ulong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_my_ulong); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_ulong) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_ulong Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_ulong = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_ulong = 0x00000005; + bool common_my_ulong_ec {false}; + CommonStructMember common_my_ulong {TypeObjectUtils::build_common_struct_member(member_id_my_ulong, member_flags_my_ulong, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_ulong, common_my_ulong_ec))}; + if (!common_my_ulong_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_ulong member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_ulong = "my_ulong"; + eprosima::fastcdr::optional member_ann_builtin_my_ulong; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_ulong = TypeObjectUtils::build_complete_member_detail(name_my_ulong, member_ann_builtin_my_ulong, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_ulong = TypeObjectUtils::build_complete_struct_member(common_my_ulong, detail_my_ulong); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_ulong); + } + { + TypeIdentifierPair type_ids_my_int8; + ReturnCode_t return_code_my_int8 {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_int8 = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int8_t", type_ids_my_int8); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_int8) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_int8 Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_int8 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_int8 = 0x00000006; + bool common_my_int8_ec {false}; + CommonStructMember common_my_int8 {TypeObjectUtils::build_common_struct_member(member_id_my_int8, member_flags_my_int8, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_int8, common_my_int8_ec))}; + if (!common_my_int8_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_int8 member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_int8 = "my_int8"; + eprosima::fastcdr::optional member_ann_builtin_my_int8; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_int8 = TypeObjectUtils::build_complete_member_detail(name_my_int8, member_ann_builtin_my_int8, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_int8 = TypeObjectUtils::build_complete_struct_member(common_my_int8, detail_my_int8); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_int8); + } + { + TypeIdentifierPair type_ids_my_uint8; + ReturnCode_t return_code_my_uint8 {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_uint8 = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint8_t", type_ids_my_uint8); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_uint8) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_uint8 Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_uint8 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_uint8 = 0x00000007; + bool common_my_uint8_ec {false}; + CommonStructMember common_my_uint8 {TypeObjectUtils::build_common_struct_member(member_id_my_uint8, member_flags_my_uint8, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_uint8, common_my_uint8_ec))}; + if (!common_my_uint8_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_uint8 member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_uint8 = "my_uint8"; + eprosima::fastcdr::optional member_ann_builtin_my_uint8; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_uint8 = TypeObjectUtils::build_complete_member_detail(name_my_uint8, member_ann_builtin_my_uint8, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_uint8 = TypeObjectUtils::build_complete_struct_member(common_my_uint8, detail_my_uint8); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_uint8); + } + { + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int16_t", type_ids_my_short); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_short Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_short = 0x00000008; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_short); + } + { + TypeIdentifierPair type_ids_my_ushort; + ReturnCode_t return_code_my_ushort {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_ushort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint16_t", type_ids_my_ushort); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_ushort) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_ushort Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_ushort = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_ushort = 0x00000009; + bool common_my_ushort_ec {false}; + CommonStructMember common_my_ushort {TypeObjectUtils::build_common_struct_member(member_id_my_ushort, member_flags_my_ushort, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_ushort, common_my_ushort_ec))}; + if (!common_my_ushort_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_ushort member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_ushort = "my_ushort"; + eprosima::fastcdr::optional member_ann_builtin_my_ushort; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_ushort = TypeObjectUtils::build_complete_member_detail(name_my_ushort, member_ann_builtin_my_ushort, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_ushort = TypeObjectUtils::build_complete_struct_member(common_my_ushort, detail_my_ushort); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_ushort); + } + { + TypeIdentifierPair type_ids_my_longlong; + ReturnCode_t return_code_my_longlong {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_longlong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_int64_t", type_ids_my_longlong); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_longlong) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_longlong Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_longlong = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_longlong = 0x0000000a; + bool common_my_longlong_ec {false}; + CommonStructMember common_my_longlong {TypeObjectUtils::build_common_struct_member(member_id_my_longlong, member_flags_my_longlong, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_longlong, common_my_longlong_ec))}; + if (!common_my_longlong_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_longlong member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_longlong = "my_longlong"; + eprosima::fastcdr::optional member_ann_builtin_my_longlong; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_longlong = TypeObjectUtils::build_complete_member_detail(name_my_longlong, member_ann_builtin_my_longlong, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_longlong = TypeObjectUtils::build_complete_struct_member(common_my_longlong, detail_my_longlong); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_longlong); + } + { + TypeIdentifierPair type_ids_my_ulonglong; + ReturnCode_t return_code_my_ulonglong {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_ulonglong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint64_t", type_ids_my_ulonglong); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_ulonglong) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_ulonglong Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_ulonglong = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_ulonglong = 0x0000000b; + bool common_my_ulonglong_ec {false}; + CommonStructMember common_my_ulonglong {TypeObjectUtils::build_common_struct_member(member_id_my_ulonglong, member_flags_my_ulonglong, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_ulonglong, common_my_ulonglong_ec))}; + if (!common_my_ulonglong_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_ulonglong member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_ulonglong = "my_ulonglong"; + eprosima::fastcdr::optional member_ann_builtin_my_ulonglong; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_ulonglong = TypeObjectUtils::build_complete_member_detail(name_my_ulonglong, member_ann_builtin_my_ulonglong, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_ulonglong = TypeObjectUtils::build_complete_struct_member(common_my_ulonglong, detail_my_ulonglong); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_ulonglong); + } + { + TypeIdentifierPair type_ids_my_float; + ReturnCode_t return_code_my_float {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_float = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_float", type_ids_my_float); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_float) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_float Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_float = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_float = 0x0000000c; + bool common_my_float_ec {false}; + CommonStructMember common_my_float {TypeObjectUtils::build_common_struct_member(member_id_my_float, member_flags_my_float, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_float, common_my_float_ec))}; + if (!common_my_float_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_float member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_float = "my_float"; + eprosima::fastcdr::optional member_ann_builtin_my_float; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_float = TypeObjectUtils::build_complete_member_detail(name_my_float, member_ann_builtin_my_float, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_float = TypeObjectUtils::build_complete_struct_member(common_my_float, detail_my_float); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_float); + } + { + TypeIdentifierPair type_ids_my_double; + ReturnCode_t return_code_my_double {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_double = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_double", type_ids_my_double); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_double) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_double Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_double = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_double = 0x0000000d; + bool common_my_double_ec {false}; + CommonStructMember common_my_double {TypeObjectUtils::build_common_struct_member(member_id_my_double, member_flags_my_double, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_double, common_my_double_ec))}; + if (!common_my_double_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_double member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_double = "my_double"; + eprosima::fastcdr::optional member_ann_builtin_my_double; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_double = TypeObjectUtils::build_complete_member_detail(name_my_double, member_ann_builtin_my_double, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_double = TypeObjectUtils::build_complete_struct_member(common_my_double, detail_my_double); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_double); + } + { + TypeIdentifierPair type_ids_my_longdouble; + ReturnCode_t return_code_my_longdouble {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_longdouble = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_longdouble", type_ids_my_longdouble); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_longdouble) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "my_longdouble Structure member TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + StructMemberFlag member_flags_my_longdouble = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_longdouble = 0x0000000e; + bool common_my_longdouble_ec {false}; + CommonStructMember common_my_longdouble {TypeObjectUtils::build_common_struct_member(member_id_my_longdouble, member_flags_my_longdouble, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_longdouble, common_my_longdouble_ec))}; + if (!common_my_longdouble_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_longdouble member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_longdouble = "my_longdouble"; + eprosima::fastcdr::optional member_ann_builtin_my_longdouble; + ann_custom_PrimitivesStruct.reset(); + CompleteMemberDetail detail_my_longdouble = TypeObjectUtils::build_complete_member_detail(name_my_longdouble, member_ann_builtin_my_longdouble, ann_custom_PrimitivesStruct); + CompleteStructMember member_my_longdouble = TypeObjectUtils::build_complete_struct_member(common_my_longdouble, detail_my_longdouble); + TypeObjectUtils::add_complete_struct_member(member_seq_PrimitivesStruct, member_my_longdouble); + } + CompleteStructType struct_type_PrimitivesStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_PrimitivesStruct, header_PrimitivesStruct, member_seq_PrimitivesStruct); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_struct_type_object(struct_type_PrimitivesStruct, type_name_PrimitivesStruct.to_string(), type_ids_PrimitivesStruct)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "PrimitivesStruct already registered in TypeObjectRegistry for a different type."); + } + } +} + diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.hpp new file mode 100644 index 00000000000..bcd2330e7f7 --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/gen/primitives_structTypeObjectSupport.hpp @@ -0,0 +1,56 @@ +// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima). +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/*! + * @file primitives_structTypeObjectSupport.hpp + * Header file containing the API required to register the TypeObject representation of the described types in the IDL file + * + * This file was generated by the tool fastddsgen. + */ + +#ifndef FAST_DDS_GENERATED__PRIMITIVES_STRUCT_TYPE_OBJECT_SUPPORT_HPP +#define FAST_DDS_GENERATED__PRIMITIVES_STRUCT_TYPE_OBJECT_SUPPORT_HPP + +#include + + +#if defined(_WIN32) +#if defined(EPROSIMA_USER_DLL_EXPORT) +#define eProsima_user_DllExport __declspec( dllexport ) +#else +#define eProsima_user_DllExport +#endif // EPROSIMA_USER_DLL_EXPORT +#else +#define eProsima_user_DllExport +#endif // _WIN32 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +/** + * @brief Register PrimitivesStruct related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_PrimitivesStruct_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC + +#endif // FAST_DDS_GENERATED__PRIMITIVES_STRUCT_TYPE_OBJECT_SUPPORT_HPP diff --git a/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl new file mode 100644 index 00000000000..eb6191cf7ea --- /dev/null +++ b/test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl @@ -0,0 +1,18 @@ +struct PrimitivesStruct +{ + boolean my_bool; + octet my_octet; + char my_char; + wchar my_wchar; + long my_long; + unsigned long my_ulong; + int8 my_int8; + uint8 my_uint8; + short my_short; + unsigned short my_ushort; + long long my_longlong; + unsigned long long my_ulonglong; + float my_float; + double my_double; + long double my_longdouble; +}; From 0fa22bd20d1491520f0609cd1388f4ebbeff8f4f Mon Sep 17 00:00:00 2001 From: tempate Date: Mon, 8 Jul 2024 16:18:14 +0200 Subject: [PATCH 40/52] Apply suggestions Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 5 +- .../serializers/idl/dynamic_type_idl.cpp | 269 +++++++++++------- .../serializers/idl/dynamic_type_idl.hpp | 52 ++-- src/cpp/utils/collections/TreeNode.hpp | 16 +- src/cpp/utils/collections/impl/TreeNode.ipp | 7 +- .../serializers/idl/DynTypeIDLTests.cpp | 3 + .../idl/types/alias_struct/alias_struct.idl | 8 +- .../types/alias_struct/gen/alias_struct.hpp | 80 +++--- .../alias_struct/gen/alias_structCdrAux.ipp | 12 +- .../gen/alias_structPubSubTypes.hpp | 2 +- .../gen/alias_structTypeObjectSupport.cxx | 164 +++++------ .../gen/alias_structTypeObjectSupport.hpp | 8 +- .../serializers/idl/types/all_types.hpp | 48 ++-- .../types/struct_struct/gen/struct_struct.hpp | 49 +++- .../struct_struct/gen/struct_structCdrAux.hpp | 4 +- .../struct_struct/gen/struct_structCdrAux.ipp | 24 +- .../gen/struct_structTypeObjectSupport.cxx | 32 ++- .../idl/types/struct_struct/struct_struct.idl | 1 + 18 files changed, 486 insertions(+), 298 deletions(-) diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index f160fa39597..e3a01a43483 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -38,10 +38,11 @@ enum class DynamicDataJsonFormat }; /** - * @brief Serializes a DynamicType into its IDL representation. + * @brief Serializes a @ref DynamicType into its IDL representation. * - * @param [in] dynamic_type The DynamicType to serialize. + * @param [in] dynamic_type The @ref DynamicType to serialize. * @param [in,out] output The IDL representation. + * @retval RETCODE_OK when serialization fully succeeds, and inner (member serialization) failing code otherwise. */ FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( const DynamicType::_ref_type& dynamic_type, diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index db81f436855..c7b804a9862 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -55,7 +55,7 @@ ReturnCode_t dyn_type_to_tree( { // If is struct, the call is recursive. // Create new tree node - TreeNode parent(member_name, type->get_name().to_string(), type); + node = TreeNode(member_name, type->get_name().to_string(), type); // Get its base class TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; @@ -63,6 +63,7 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } @@ -72,20 +73,22 @@ ReturnCode_t dyn_type_to_tree( if (nullptr != base_type) { - TreeNode child; - ret = dyn_type_to_tree(base_type, "PARENT", child); + TreeNode base; + ret = dyn_type_to_tree(base_type, "PARENT", base); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting base type of " << node << "."); return ret; } - child.info.is_base = true; + base.info.is_base = true; - // If the struct is derived from a base, the first members of the struct are the members of the base. + // If the struct is derived from a base, according to the xtypes standard, the first members of the + // struct are the members of the base. first_member = base_type->get_member_count(); - parent.add_branch(child); + node.add_branch(base); } // Add each member as a new branch except for the members of its base class @@ -96,6 +99,8 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -104,6 +109,9 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member descriptor of member " << member->get_name() << + " of " << node << "."); return ret; } @@ -112,16 +120,17 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error building tree of member " << member->get_name() << + " of " << node << "."); return ret; } child.info.is_key = member_descriptor->is_key(); // Add each member with its name as a new child in a branch (recursion) - parent.add_branch(child); + node.add_branch(child); } - - node = parent; } else { @@ -130,53 +139,58 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << type->get_name().to_string() << "."); return ret; } node = TreeNode(member_name, idl.str(), type); - if (kind == TK_ARRAY || kind == TK_SEQUENCE) + if (kind == TK_ALIAS) { - // If container (array or sequence) has exactly one branch - // Calculate child branch - DynamicType::_ref_type internal_type; - ret = container_internal_type(type, internal_type); + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = node.info.dynamic_type->get_descriptor(type_descriptor); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } - TreeNode child; - ret = dyn_type_to_tree(internal_type, "CONTAINER_MEMBER", child); + // Add a branch for the base type of the alias + TreeNode base; + ret = dyn_type_to_tree(type_descriptor->base_type(), "BASE", base); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error building tree of " << base << "."); return ret; } - node.add_branch(child); + node.add_branch(base); } - else if (kind == TK_MAP) + else if (kind == TK_ARRAY || kind == TK_MAP || kind == TK_SEQUENCE) { - // Add value branch - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = type->get_descriptor(type_descriptor); + // Add a branch for the element type of the container + DynamicType::_ref_type element_type; + ret = get_element_type(type, element_type); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting element type of " << node << "."); return ret; } - TreeNode value; - ret = dyn_type_to_tree(type_descriptor->element_type(), "VALUE", value); + TreeNode child; + ret = dyn_type_to_tree(element_type, "CONTAINER_MEMBER", child); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error building tree of " << child << "."); return ret; } - node.add_branch(value); + node.add_branch(child); } else if (kind == TK_UNION) { @@ -188,6 +202,8 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -196,6 +212,9 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member descriptor of member " << member->get_name() << + " of " << node << "."); return ret; } @@ -204,6 +223,9 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error building tree of member " << member->get_name() << + " of " << node << "."); return ret; } @@ -221,7 +243,9 @@ ReturnCode_t type_kind_to_idl( { ReturnCode_t ret = RETCODE_OK; - switch (dyn_type->get_kind()) + const auto kind = dyn_type->get_kind(); + + switch (kind) { case TK_BOOLEAN: { @@ -331,11 +355,13 @@ ReturnCode_t type_kind_to_idl( } case TK_NONE: { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Failed to convert TK_NONE to stream."); ret = RETCODE_UNSUPPORTED; break; } default: { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Failed to convert unknown type (" << kind << ") to stream."); ret = RETCODE_BAD_PARAMETER; break; } @@ -352,26 +378,32 @@ ReturnCode_t array_kind_to_idl( ReturnCode_t ret = RETCODE_OK; - DynamicType::_ref_type internal_type; - ret = container_internal_type(dyn_type, internal_type); + DynamicType::_ref_type element_type; + ret = get_element_type(dyn_type, element_type); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting element type of " << dyn_type->get_name().to_string() << "."); return ret; } - ret = type_kind_to_idl(internal_type, idl); + ret = type_kind_to_idl(element_type, idl); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << element_type->get_name().to_string() << "."); return ret; } BoundSeq bounds; - ret = container_size(dyn_type, bounds); + ret = get_bounds(dyn_type, bounds); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -396,6 +428,8 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -406,6 +440,8 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << key_type->get_name().to_string() << "."); return ret; } @@ -416,18 +452,24 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << value_type->get_name().to_string() << "."); return ret; } BoundSeq bounds; - ret = container_size(dyn_type, bounds); + ret = get_bounds(dyn_type, bounds); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } - if (bounds.size() == 1) + assert(bounds.size() <= 1); + + if (1 == bounds.size()) { idl << ", " << std::to_string(bounds[0]); } @@ -445,31 +487,39 @@ ReturnCode_t sequence_kind_to_idl( ReturnCode_t ret = RETCODE_OK; - DynamicType::_ref_type internal_type; - ret = container_internal_type(dyn_type, internal_type); + DynamicType::_ref_type element_type; + ret = get_element_type(dyn_type, element_type); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting element type of " << dyn_type->get_name().to_string() << "."); return ret; } idl << "sequence<"; - ret = type_kind_to_idl(internal_type, idl); + ret = type_kind_to_idl(element_type, idl); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << element_type->get_name().to_string() << "."); return ret; } BoundSeq bounds; - ret = container_size(dyn_type, bounds); + ret = get_bounds(dyn_type, bounds); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } + assert(bounds.size() <= 1); + if (1 == bounds.size()) { idl << ", " << std::to_string(bounds[0]); @@ -498,13 +548,17 @@ ReturnCode_t string_kind_to_idl( } BoundSeq bounds; - ret = container_size(dyn_type, bounds); + ret = get_bounds(dyn_type, bounds); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } + assert(bounds.size() <= 1); + if (1 == bounds.size()) { idl << "<" << std::to_string(bounds[0]) << ">"; @@ -513,51 +567,6 @@ ReturnCode_t string_kind_to_idl( return ret; } -ReturnCode_t container_internal_type( - const DynamicType::_ref_type& dyn_type, - DynamicType::_ref_type& internal_type) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = dyn_type->get_descriptor(type_descriptor); - - if (RETCODE_OK != ret) - { - return ret; - } - - internal_type = type_descriptor->element_type(); - - return ret; -} - -ReturnCode_t container_size( - const DynamicType::_ref_type& dyn_type, - BoundSeq& bounds) noexcept -{ - ReturnCode_t ret = RETCODE_OK; - - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = dyn_type->get_descriptor(type_descriptor); - - if (RETCODE_OK != ret) - { - return ret; - } - - bounds = type_descriptor->bound(); - - static const auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); - - if (1 == bounds.size() && UNBOUNDED == bounds[0]) - { - bounds.clear(); - } - - return ret; -} - ////////////////////////////// // DYNAMIC TYPE TREE TO IDL // ////////////////////////////// @@ -570,13 +579,12 @@ ReturnCode_t dyn_type_tree_to_idl( std::set types_written; - // For every Node, check if it is of a "writable" type (i.e. struct, enum or union). - // If it is, check if it is not yet written - // If it is not, write it down + // Write the dependencies of the root node for (const auto& node : root.all_nodes()) { if (types_written.find(node.info.type_kind_name) != types_written.end()) { + // The type has already been written. Skip it. continue; } @@ -622,6 +630,7 @@ ReturnCode_t dyn_type_tree_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error writing " << node.info.type_kind_name << " to IDL."); return ret; } @@ -629,11 +638,12 @@ ReturnCode_t dyn_type_tree_to_idl( types_written.insert(node.info.type_kind_name); } - // Write struct parent node at last, after all its dependencies + // Write the struct root node at last, after all its dependencies ret = struct_to_idl(root, idl); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error writing " << root.info.type_kind_name << " to IDL."); return ret; } @@ -653,6 +663,7 @@ ReturnCode_t alias_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } @@ -663,6 +674,7 @@ ReturnCode_t alias_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting IDL representation of " << node << "."); return ret; } @@ -679,23 +691,24 @@ ReturnCode_t bitmask_to_idl( ReturnCode_t ret = RETCODE_OK; - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = node.info.dynamic_type->get_descriptor(type_descriptor); + BoundSeq bounds; + ret = get_bounds(node.info.dynamic_type, bounds); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting bounds of " << node << "."); return ret; } - if (1 != type_descriptor->bound().size()) + if (1 != bounds.size()) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Bitmask type must have exactly one bound."); + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Bitmask type has " << bounds.size() << " bounds instead of one."); return RETCODE_BAD_PARAMETER; } // Annotation with the bitmask size static constexpr std::uint32_t DEFAULT_BITMASK_SIZE = 32; - const auto bitmask_size = type_descriptor->bound()[0]; + const auto bitmask_size = bounds[0]; if (DEFAULT_BITMASK_SIZE != bitmask_size) { @@ -715,6 +728,7 @@ ReturnCode_t bitmask_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -763,6 +777,7 @@ ReturnCode_t bitset_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } @@ -778,6 +793,7 @@ ReturnCode_t bitset_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -800,6 +816,7 @@ ReturnCode_t bitset_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting member descriptor of " << member->get_name() << "."); return ret; } @@ -808,6 +825,7 @@ ReturnCode_t bitset_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting default type kind."); return ret; } @@ -849,6 +867,7 @@ ReturnCode_t enum_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -880,6 +899,7 @@ ReturnCode_t struct_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } @@ -902,7 +922,7 @@ ReturnCode_t struct_to_idl( } default: { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Extensibility kind not supported."); + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Extensibility kind not supported."); return RETCODE_BAD_PARAMETER; } } @@ -910,15 +930,19 @@ ReturnCode_t struct_to_idl( // Add types name idl << "struct " << node.info.type_kind_name; + const auto base_type = type_descriptor->base_type(); + // Add inheritance - if (nullptr != type_descriptor->base_type()) + if (nullptr != base_type) { idl << " : "; - ret = type_kind_to_idl(type_descriptor->base_type(), idl); + ret = type_kind_to_idl(base_type, idl); if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting IDL representation of " << base_type->get_name().to_string() << "."); return ret; } } @@ -957,6 +981,7 @@ ReturnCode_t union_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); return ret; } @@ -981,6 +1006,7 @@ ReturnCode_t union_to_idl( if (RETCODE_OK != ret) { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting member descriptor of " << member->get_name() << "."); return ret; } @@ -1031,7 +1057,7 @@ ReturnCode_t node_to_idl( if (std::string::npos == dim_pos) { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Array type name is not well formed."); + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Array type name is not well formed."); return RETCODE_BAD_PARAMETER; } @@ -1048,6 +1074,59 @@ ReturnCode_t node_to_idl( return RETCODE_OK; } +/////////////////////// +// AUXILIARY METHODS // +/////////////////////// + +ReturnCode_t get_element_type( + const DynamicType::_ref_type& dyn_type, + DynamicType::_ref_type& element_type) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = dyn_type->get_descriptor(type_descriptor); + + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); + return ret; + } + + element_type = type_descriptor->element_type(); + + return ret; +} + +ReturnCode_t get_bounds( + const DynamicType::_ref_type& dyn_type, + BoundSeq& bounds) noexcept +{ + ReturnCode_t ret = RETCODE_OK; + + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = dyn_type->get_descriptor(type_descriptor); + + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); + return ret; + } + + bounds = type_descriptor->bound(); + + static constexpr auto UNBOUNDED = static_cast(LENGTH_UNLIMITED); + + if (1 == bounds.size() && UNBOUNDED == bounds[0]) + { + bounds.clear(); + } + + return ret; +} + ReturnCode_t get_default_type_kind( const std::uint32_t size, TypeKind& default_type) noexcept @@ -1074,7 +1153,7 @@ ReturnCode_t get_default_type_kind( } else { - EPROSIMA_LOG_ERROR(DYN_TYPES, "Size " << size << " is not supported."); + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Size " << size << " is not supported."); return RETCODE_BAD_PARAMETER; } diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp index 235b855a9f8..97ea39fa0b1 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp @@ -61,6 +61,13 @@ struct TreeNodeType bool is_key; }; +inline std::ostream& operator <<( + std::ostream& output, + const TreeNodeType& info) +{ + output << info.type_kind_name; + return output; +} ////////////////////////// // DYNAMIC TYPE TO TREE // @@ -128,27 +135,6 @@ ReturnCode_t string_kind_to_idl( const DynamicType::_ref_type& dyn_type, std::ostream& idl) noexcept; -/** - * @brief Gathers the \c element_type of the DynamicType. - * - * @param dyn_type The DynamicType to gather the members from. - * @param internal_type The internal type of the DynamicType's \c type_descriptor. - */ -ReturnCode_t container_internal_type( - const DynamicType::_ref_type& dyn_type, - DynamicType::_ref_type& internal_type) noexcept; - -/** - * @brief Gathers the \c bounds of the DynamicType. - * - * @param dyn_type The DynamicType to gather the members from. - * @param bounds The vector to store the bounds in. - */ -ReturnCode_t container_size( - const DynamicType::_ref_type& dyn_type, - BoundSeq& bounds) noexcept; - - ////////////////////////////// // DYNAMIC TYPE TREE TO IDL // ////////////////////////////// @@ -233,6 +219,30 @@ ReturnCode_t node_to_idl( const utilities::collections::TreeNode& node, std::ostream& idl) noexcept; +/////////////////////// +// AUXILIARY METHODS // +/////////////////////// + +/** + * @brief Gathers the \c element_type of the DynamicType. + * + * @param dyn_type The DynamicType to gather the members from. + * @param element_type The element type of the DynamicType's \c type_descriptor. + */ +ReturnCode_t get_element_type( + const DynamicType::_ref_type& dyn_type, + DynamicType::_ref_type& element_type) noexcept; + +/** + * @brief Gathers the \c bounds of the DynamicType. + * + * @param dyn_type The DynamicType to gather the members from. + * @param bounds The vector to store the bounds in. + */ +ReturnCode_t get_bounds( + const DynamicType::_ref_type& dyn_type, + BoundSeq& bounds) noexcept; + /** * @brief Finds the default type kind for a variable with a given size. * diff --git a/src/cpp/utils/collections/TreeNode.hpp b/src/cpp/utils/collections/TreeNode.hpp index 25b9830ebf6..ce3426dbefb 100644 --- a/src/cpp/utils/collections/TreeNode.hpp +++ b/src/cpp/utils/collections/TreeNode.hpp @@ -14,11 +14,10 @@ /** * @file TreeNode.hpp - * */ -#ifndef FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ -#define FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ +#ifndef FASTDDS_UTILS_COLLECTIONS__TREE_NODE_HPP +#define FASTDDS_UTILS_COLLECTIONS__TREE_NODE_HPP #include @@ -79,6 +78,15 @@ class TreeNode : public Node std::list branches_; }; +template +inline std::ostream& operator <<( + std::ostream& output, + const TreeNode& node) +{ + output << node.info; + return output; +} + } /* namespace collections */ } /* namespace utilities */ } /* namespace eprosima */ @@ -86,4 +94,4 @@ class TreeNode : public Node // Include implementation template file #include "impl/TreeNode.ipp" -#endif /* FASTDDS_UTILS_COLLECTIONS_TREE_HPP_ */ +#endif /* FASTDDS_UTILS_COLLECTIONS__TREE_NODE_HPP */ diff --git a/src/cpp/utils/collections/impl/TreeNode.ipp b/src/cpp/utils/collections/impl/TreeNode.ipp index f22d7a1408d..707d6a06394 100644 --- a/src/cpp/utils/collections/impl/TreeNode.ipp +++ b/src/cpp/utils/collections/impl/TreeNode.ipp @@ -14,11 +14,10 @@ /** * @file TreeNode.ipp - * */ -#ifndef SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ -#define SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ +#ifndef FASTDDS_UTILS_COLLECTIONS_IMPL__TREE_NODE_IPP +#define FASTDDS_UTILS_COLLECTIONS_IMPL__TREE_NODE_IPP #include @@ -128,4 +127,4 @@ std::list> TreeNode::all_nodes() const noexcept } /* namespace utilities */ } /* namespace eprosima */ -#endif /* SRC_CPP_UTILS_COLLECTIONS_IMPL_TREE_IPP_ */ +#endif /* FASTDDS_UTILS_COLLECTIONS_IMPL__TREE_NODE_IPP */ diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index 187d12fc424..0b8bcee49cb 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -104,11 +104,14 @@ TEST_P(DynTypeIDLTests, to_idl) // Get Dynamic type DynamicType::_ref_type dyn_type; get_dynamic_type(snake_to_camel(type), dyn_type); + ASSERT_NE(dyn_type, nullptr); // Serialize DynamicType to IDL std::stringstream idl_serialization; ASSERT_EQ(idl_serialize(dyn_type, idl_serialization), RETCODE_OK); + std::cout << idl_serialization.str() << std::endl; + // Compare IDLs ASSERT_EQ(idl_file, idl_serialization.str()); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl index b30dd6b8049..926dd97fef6 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl @@ -1,12 +1,12 @@ typedef short MyShort; -typedef unsigned long MyLong; - typedef MyShort MyRecursiveShort; +typedef unsigned long MyLong; + struct AliasStruct { - MyShort my_short; - MyLong my_long; MyRecursiveShort my_recursive_short; + MyLong my_long; + MyShort my_short; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp index d267c51b0a1..c35257a26c0 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp @@ -51,10 +51,10 @@ typedef int16_t MyShort; -typedef uint32_t MyLong; - typedef MyShort MyRecursiveShort; +typedef uint32_t MyLong; + /*! * @brief This class represents the structure AliasStruct defined by the user in the IDL file. * @ingroup alias_struct @@ -84,11 +84,11 @@ class AliasStruct eProsima_user_DllExport AliasStruct( const AliasStruct& x) { - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; m_my_long = x.m_my_long; - m_my_recursive_short = x.m_my_recursive_short; + m_my_short = x.m_my_short; } @@ -99,9 +99,9 @@ class AliasStruct eProsima_user_DllExport AliasStruct( AliasStruct&& x) noexcept { - m_my_short = x.m_my_short; - m_my_long = x.m_my_long; m_my_recursive_short = x.m_my_recursive_short; + m_my_long = x.m_my_long; + m_my_short = x.m_my_short; } /*! @@ -112,11 +112,11 @@ class AliasStruct const AliasStruct& x) { - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; m_my_long = x.m_my_long; - m_my_recursive_short = x.m_my_recursive_short; + m_my_short = x.m_my_short; return *this; } @@ -129,9 +129,9 @@ class AliasStruct AliasStruct&& x) noexcept { - m_my_short = x.m_my_short; - m_my_long = x.m_my_long; m_my_recursive_short = x.m_my_recursive_short; + m_my_long = x.m_my_long; + m_my_short = x.m_my_short; return *this; } @@ -142,9 +142,9 @@ class AliasStruct eProsima_user_DllExport bool operator ==( const AliasStruct& x) const { - return (m_my_short == x.m_my_short && + return (m_my_recursive_short == x.m_my_recursive_short && m_my_long == x.m_my_long && - m_my_recursive_short == x.m_my_recursive_short); + m_my_short == x.m_my_short); } /*! @@ -158,31 +158,31 @@ class AliasStruct } /*! - * @brief This function sets a value in member my_short - * @param _my_short New value for member my_short + * @brief This function sets a value in member my_recursive_short + * @param _my_recursive_short New value for member my_recursive_short */ - eProsima_user_DllExport void my_short( - MyShort _my_short) + eProsima_user_DllExport void my_recursive_short( + MyRecursiveShort _my_recursive_short) { - m_my_short = _my_short; + m_my_recursive_short = _my_recursive_short; } /*! - * @brief This function returns the value of member my_short - * @return Value of member my_short + * @brief This function returns the value of member my_recursive_short + * @return Value of member my_recursive_short */ - eProsima_user_DllExport MyShort my_short() const + eProsima_user_DllExport MyRecursiveShort my_recursive_short() const { - return m_my_short; + return m_my_recursive_short; } /*! - * @brief This function returns a reference to member my_short - * @return Reference to member my_short + * @brief This function returns a reference to member my_recursive_short + * @return Reference to member my_recursive_short */ - eProsima_user_DllExport MyShort& my_short() + eProsima_user_DllExport MyRecursiveShort& my_recursive_short() { - return m_my_short; + return m_my_recursive_short; } @@ -216,40 +216,40 @@ class AliasStruct /*! - * @brief This function sets a value in member my_recursive_short - * @param _my_recursive_short New value for member my_recursive_short + * @brief This function sets a value in member my_short + * @param _my_short New value for member my_short */ - eProsima_user_DllExport void my_recursive_short( - MyRecursiveShort _my_recursive_short) + eProsima_user_DllExport void my_short( + MyShort _my_short) { - m_my_recursive_short = _my_recursive_short; + m_my_short = _my_short; } /*! - * @brief This function returns the value of member my_recursive_short - * @return Value of member my_recursive_short + * @brief This function returns the value of member my_short + * @return Value of member my_short */ - eProsima_user_DllExport MyRecursiveShort my_recursive_short() const + eProsima_user_DllExport MyShort my_short() const { - return m_my_recursive_short; + return m_my_short; } /*! - * @brief This function returns a reference to member my_recursive_short - * @return Reference to member my_recursive_short + * @brief This function returns a reference to member my_short + * @return Reference to member my_short */ - eProsima_user_DllExport MyRecursiveShort& my_recursive_short() + eProsima_user_DllExport MyShort& my_short() { - return m_my_recursive_short; + return m_my_short; } private: - MyShort m_my_short{0}; - MyLong m_my_long{0}; MyRecursiveShort m_my_recursive_short{0}; + MyLong m_my_long{0}; + MyShort m_my_short{0}; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp index 267fca2ea5f..712da4efda5 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp @@ -51,13 +51,13 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.my_short(), current_alignment); + data.my_recursive_short(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.my_long(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.my_recursive_short(), current_alignment); + data.my_short(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -77,9 +77,9 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.my_short() + << eprosima::fastcdr::MemberId(0) << data.my_recursive_short() << eprosima::fastcdr::MemberId(1) << data.my_long() - << eprosima::fastcdr::MemberId(2) << data.my_recursive_short() + << eprosima::fastcdr::MemberId(2) << data.my_short() ; scdr.end_serialize_type(current_state); } @@ -98,7 +98,7 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.my_short(); + dcdr >> data.my_recursive_short(); break; case 1: @@ -106,7 +106,7 @@ eProsima_user_DllExport void deserialize( break; case 2: - dcdr >> data.my_recursive_short(); + dcdr >> data.my_short(); break; default: diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp index 74c77cfe142..5989a45d815 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp @@ -38,8 +38,8 @@ #endif // GEN_API_VER typedef int16_t MyShort; -typedef uint32_t MyLong; typedef MyShort MyRecursiveShort; +typedef uint32_t MyLong; /*! * @brief This class represents the TopicDataType of the type AliasStruct defined by the user in the IDL file. diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx index 9729c554eae..ed1cbdc2148 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx @@ -88,6 +88,54 @@ void register_MyShort_type_identifier( } } +void register_MyRecursiveShort_type_identifier( + TypeIdentifierPair& type_ids_MyRecursiveShort) +{ + ReturnCode_t return_code_MyRecursiveShort {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyRecursiveShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyRecursiveShort", type_ids_MyRecursiveShort); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) + { + AliasTypeFlag alias_flags_MyRecursiveShort = 0; + QualifiedTypeName type_name_MyRecursiveShort = "MyRecursiveShort"; + eprosima::fastcdr::optional type_ann_builtin_MyRecursiveShort; + eprosima::fastcdr::optional ann_custom_MyRecursiveShort; + CompleteTypeDetail detail_MyRecursiveShort = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort, type_name_MyRecursiveShort.to_string()); + CompleteAliasHeader header_MyRecursiveShort = TypeObjectUtils::build_complete_alias_header(detail_MyRecursiveShort); + AliasMemberFlag related_flags_MyRecursiveShort = 0; + return_code_MyRecursiveShort = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyShort", type_ids_MyRecursiveShort); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) + { + ::register_MyShort_type_identifier(type_ids_MyRecursiveShort); + } + bool common_MyRecursiveShort_ec {false}; + CommonAliasBody common_MyRecursiveShort {TypeObjectUtils::build_common_alias_body(related_flags_MyRecursiveShort, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyRecursiveShort, common_MyRecursiveShort_ec))}; + if (!common_MyRecursiveShort_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyRecursiveShort related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyRecursiveShort; + ann_custom_MyRecursiveShort.reset(); + CompleteAliasBody body_MyRecursiveShort = TypeObjectUtils::build_complete_alias_body(common_MyRecursiveShort, + member_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort); + CompleteAliasType alias_type_MyRecursiveShort = TypeObjectUtils::build_complete_alias_type(alias_flags_MyRecursiveShort, + header_MyRecursiveShort, body_MyRecursiveShort); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyRecursiveShort, + type_name_MyRecursiveShort.to_string(), type_ids_MyRecursiveShort)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyRecursiveShort already registered in TypeObjectRegistry for a different type."); + } + } +} + void register_MyLong_type_identifier( TypeIdentifierPair& type_ids_MyLong) { @@ -138,54 +186,6 @@ void register_MyLong_type_identifier( } } -void register_MyRecursiveShort_type_identifier( - TypeIdentifierPair& type_ids_MyRecursiveShort) -{ - ReturnCode_t return_code_MyRecursiveShort {eprosima::fastdds::dds::RETCODE_OK}; - return_code_MyRecursiveShort = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyRecursiveShort", type_ids_MyRecursiveShort); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) - { - AliasTypeFlag alias_flags_MyRecursiveShort = 0; - QualifiedTypeName type_name_MyRecursiveShort = "MyRecursiveShort"; - eprosima::fastcdr::optional type_ann_builtin_MyRecursiveShort; - eprosima::fastcdr::optional ann_custom_MyRecursiveShort; - CompleteTypeDetail detail_MyRecursiveShort = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort, type_name_MyRecursiveShort.to_string()); - CompleteAliasHeader header_MyRecursiveShort = TypeObjectUtils::build_complete_alias_header(detail_MyRecursiveShort); - AliasMemberFlag related_flags_MyRecursiveShort = 0; - return_code_MyRecursiveShort = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyShort", type_ids_MyRecursiveShort); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveShort) - { - ::register_MyShort_type_identifier(type_ids_MyRecursiveShort); - } - bool common_MyRecursiveShort_ec {false}; - CommonAliasBody common_MyRecursiveShort {TypeObjectUtils::build_common_alias_body(related_flags_MyRecursiveShort, - TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyRecursiveShort, common_MyRecursiveShort_ec))}; - if (!common_MyRecursiveShort_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyRecursiveShort related TypeIdentifier inconsistent."); - return; - } - eprosima::fastcdr::optional member_ann_builtin_MyRecursiveShort; - ann_custom_MyRecursiveShort.reset(); - CompleteAliasBody body_MyRecursiveShort = TypeObjectUtils::build_complete_alias_body(common_MyRecursiveShort, - member_ann_builtin_MyRecursiveShort, ann_custom_MyRecursiveShort); - CompleteAliasType alias_type_MyRecursiveShort = TypeObjectUtils::build_complete_alias_type(alias_flags_MyRecursiveShort, - header_MyRecursiveShort, body_MyRecursiveShort); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyRecursiveShort, - type_name_MyRecursiveShort.to_string(), type_ids_MyRecursiveShort)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "MyRecursiveShort already registered in TypeObjectRegistry for a different type."); - } - } -} - // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method void register_AliasStruct_type_identifier( TypeIdentifierPair& type_ids_AliasStruct) @@ -207,32 +207,32 @@ void register_AliasStruct_type_identifier( header_AliasStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AliasStruct); CompleteStructMemberSeq member_seq_AliasStruct; { - TypeIdentifierPair type_ids_my_short; - ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_short = + TypeIdentifierPair type_ids_my_recursive_short; + ReturnCode_t return_code_my_recursive_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_recursive_short = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyShort", type_ids_my_short); + "MyRecursiveShort", type_ids_my_recursive_short); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_short) { - ::register_MyShort_type_identifier(type_ids_my_short); + ::register_MyRecursiveShort_type_identifier(type_ids_my_recursive_short); } - StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_recursive_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_short = 0x00000000; - bool common_my_short_ec {false}; - CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; - if (!common_my_short_ec) + MemberId member_id_my_recursive_short = 0x00000000; + bool common_my_recursive_short_ec {false}; + CommonStructMember common_my_recursive_short {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_short, member_flags_my_recursive_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_short, common_my_recursive_short_ec))}; + if (!common_my_recursive_short_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_short member TypeIdentifier inconsistent."); return; } - MemberName name_my_short = "my_short"; - eprosima::fastcdr::optional member_ann_builtin_my_short; + MemberName name_my_recursive_short = "my_recursive_short"; + eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; ann_custom_AliasStruct.reset(); - CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_AliasStruct); - CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); - TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_short); + CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_AliasStruct); + CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); } { TypeIdentifierPair type_ids_my_long; @@ -263,32 +263,32 @@ void register_AliasStruct_type_identifier( TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_long); } { - TypeIdentifierPair type_ids_my_recursive_short; - ReturnCode_t return_code_my_recursive_short {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_recursive_short = + TypeIdentifierPair type_ids_my_short; + ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_short = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyRecursiveShort", type_ids_my_recursive_short); + "MyShort", type_ids_my_short); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_short) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) { - ::register_MyRecursiveShort_type_identifier(type_ids_my_recursive_short); + ::register_MyShort_type_identifier(type_ids_my_short); } - StructMemberFlag member_flags_my_recursive_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_recursive_short = 0x00000002; - bool common_my_recursive_short_ec {false}; - CommonStructMember common_my_recursive_short {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_short, member_flags_my_recursive_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_short, common_my_recursive_short_ec))}; - if (!common_my_recursive_short_ec) + MemberId member_id_my_short = 0x00000002; + bool common_my_short_ec {false}; + CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; + if (!common_my_short_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_short member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); return; } - MemberName name_my_recursive_short = "my_recursive_short"; - eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; + MemberName name_my_short = "my_short"; + eprosima::fastcdr::optional member_ann_builtin_my_short; ann_custom_AliasStruct.reset(); - CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_AliasStruct); - CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); - TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); + CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_AliasStruct); + CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_short); } CompleteStructType struct_type_AliasStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AliasStruct, header_AliasStruct, member_seq_AliasStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp index 82de769e185..19b43e90e8b 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp @@ -52,7 +52,7 @@ eProsima_user_DllExport void register_MyShort_type_identifier( /** - * @brief Register MyLong related TypeIdentifier. + * @brief Register MyRecursiveShort related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -61,12 +61,12 @@ eProsima_user_DllExport void register_MyShort_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyLong_type_identifier( +eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register MyRecursiveShort related TypeIdentifier. + * @brief Register MyLong related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -75,7 +75,7 @@ eProsima_user_DllExport void register_MyLong_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( +eProsima_user_DllExport void register_MyLong_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp index 8875b72f195..2f87e7a6299 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/all_types.hpp @@ -16,6 +16,9 @@ * @file all_types.hpp */ +#ifndef TEST_UNITTEST_DDS_XTYPES_SERIALIZERS_IDL_TYPES__ALL_TYPES_HPP +#define TEST_UNITTEST_DDS_XTYPES_SERIALIZERS_IDL_TYPES__ALL_TYPES_HPP + #include #include @@ -100,75 +103,68 @@ void register_type_object_representation( { using namespace eprosima::fastdds::dds; + TypeSupport type_support; + if (type_name == SupportedTypes::ALIAS_STRUCT) { - TypeSupport type_alias_struct(new AliasStructPubSubType()); - type_alias_struct->register_type_object_representation(); + type_support.reset(new AliasStructPubSubType()); } else if (type_name == SupportedTypes::ARRAY_STRUCT) { - TypeSupport type_array_struct(new ArrayStructPubSubType()); - type_array_struct->register_type_object_representation(); + type_support.reset(new ArrayStructPubSubType()); } else if (type_name == SupportedTypes::BITMASK_STRUCT) { - TypeSupport type_bitmask_struct(new BitmaskStructPubSubType()); - type_bitmask_struct->register_type_object_representation(); + type_support.reset(new BitmaskStructPubSubType()); } else if (type_name == SupportedTypes::BITSET_STRUCT) { - TypeSupport type_bitset_struct(new BitsetStructPubSubType()); - type_bitset_struct->register_type_object_representation(); + type_support.reset(new BitsetStructPubSubType()); } else if (type_name == SupportedTypes::ENUM_STRUCT) { - TypeSupport type_enum_struct(new EnumStructPubSubType()); - type_enum_struct->register_type_object_representation(); + type_support.reset(new EnumStructPubSubType()); } else if (type_name == SupportedTypes::EXTENSIBILITY_STRUCT) { - TypeSupport type_extensibility_struct(new ExtensibilityStructPubSubType()); - type_extensibility_struct->register_type_object_representation(); + type_support.reset(new ExtensibilityStructPubSubType()); } else if (type_name == SupportedTypes::KEY_STRUCT) { - TypeSupport type_key_struct(new KeyStructPubSubType()); - type_key_struct->register_type_object_representation(); + type_support.reset(new KeyStructPubSubType()); } else if (type_name == SupportedTypes::MAP_STRUCT) { - TypeSupport type_map_struct(new MapStructPubSubType()); - type_map_struct->register_type_object_representation(); + type_support.reset(new MapStructPubSubType()); } else if (type_name == SupportedTypes::PRIMITIVE_STRUCT) { - TypeSupport type_primitives_struct(new PrimitivesStructPubSubType()); - type_primitives_struct->register_type_object_representation(); + type_support.reset(new PrimitivesStructPubSubType()); } else if (type_name == SupportedTypes::SEQUENCE_STRUCT) { - TypeSupport type_sequence_struct(new SequenceStructPubSubType()); - type_sequence_struct->register_type_object_representation(); + type_support.reset(new SequenceStructPubSubType()); } else if (type_name == SupportedTypes::STRING_STRUCT) { - TypeSupport type_string_struct(new StringStructPubSubType()); - type_string_struct->register_type_object_representation(); + type_support.reset(new StringStructPubSubType()); } else if (type_name == SupportedTypes::STRUCT_STRUCT) { - TypeSupport type_struct_struct(new StructStructPubSubType()); - type_struct_struct->register_type_object_representation(); + type_support.reset(new StructStructPubSubType()); } else if (type_name == SupportedTypes::UNION_STRUCT) { - TypeSupport type_union_struct(new UnionStructPubSubType()); - type_union_struct->register_type_object_representation(); + type_support.reset(new UnionStructPubSubType()); } else { ASSERT_FALSE(true) << "Type not supported"; } + + type_support->register_type_object_representation(); } } /* namespace test */ + +#endif /* TEST_UNITTEST_DDS_XTYPES_SERIALIZERS_IDL_TYPES__ALL_TYPES_HPP */ diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp index c7d74da812a..b6a0f41d9de 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_struct.hpp @@ -209,6 +209,8 @@ class ParentStruct : public GrandparentStruct m_my_string = x.m_my_string; + m_my_grandparent = x.m_my_grandparent; + } /*! @@ -222,6 +224,7 @@ class ParentStruct : public GrandparentStruct { m_my_short = x.m_my_short; m_my_string = std::move(x.m_my_string); + m_my_grandparent = std::move(x.m_my_grandparent); } /*! @@ -237,6 +240,8 @@ class ParentStruct : public GrandparentStruct m_my_string = x.m_my_string; + m_my_grandparent = x.m_my_grandparent; + return *this; } @@ -251,6 +256,7 @@ class ParentStruct : public GrandparentStruct m_my_short = x.m_my_short; m_my_string = std::move(x.m_my_string); + m_my_grandparent = std::move(x.m_my_grandparent); return *this; } @@ -266,7 +272,8 @@ class ParentStruct : public GrandparentStruct return false; } return (m_my_short == x.m_my_short && - m_my_string == x.m_my_string); + m_my_string == x.m_my_string && + m_my_grandparent == x.m_my_grandparent); } /*! @@ -347,11 +354,51 @@ class ParentStruct : public GrandparentStruct } + /*! + * @brief This function copies the value in member my_grandparent + * @param _my_grandparent New value to be copied in member my_grandparent + */ + eProsima_user_DllExport void my_grandparent( + const GrandparentStruct& _my_grandparent) + { + m_my_grandparent = _my_grandparent; + } + + /*! + * @brief This function moves the value in member my_grandparent + * @param _my_grandparent New value to be moved in member my_grandparent + */ + eProsima_user_DllExport void my_grandparent( + GrandparentStruct&& _my_grandparent) + { + m_my_grandparent = std::move(_my_grandparent); + } + + /*! + * @brief This function returns a constant reference to member my_grandparent + * @return Constant reference to member my_grandparent + */ + eProsima_user_DllExport const GrandparentStruct& my_grandparent() const + { + return m_my_grandparent; + } + + /*! + * @brief This function returns a reference to member my_grandparent + * @return Reference to member my_grandparent + */ + eProsima_user_DllExport GrandparentStruct& my_grandparent() + { + return m_my_grandparent; + } + + private: int16_t m_my_short{0}; std::string m_my_string; + GrandparentStruct m_my_grandparent; }; /*! diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp index 2d06ac6872a..9d875c61cf0 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.hpp @@ -27,13 +27,13 @@ constexpr uint32_t NestedStructElement_max_cdr_typesize {5UL}; constexpr uint32_t NestedStructElement_max_key_cdr_typesize {0UL}; -constexpr uint32_t ParentStruct_max_cdr_typesize {272UL}; +constexpr uint32_t ParentStruct_max_cdr_typesize {280UL}; constexpr uint32_t ParentStruct_max_key_cdr_typesize {0UL}; constexpr uint32_t GrandparentStruct_max_cdr_typesize {8UL}; constexpr uint32_t GrandparentStruct_max_key_cdr_typesize {0UL}; -constexpr uint32_t StructStruct_max_cdr_typesize {278UL}; +constexpr uint32_t StructStruct_max_cdr_typesize {286UL}; constexpr uint32_t StructStruct_max_key_cdr_typesize {0UL}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp index b87fa71512e..33dc9b42416 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structCdrAux.ipp @@ -135,6 +135,9 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), data.my_string(), current_alignment); + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_grandparent(), current_alignment); + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -156,6 +159,7 @@ eProsima_user_DllExport void serialize( << eprosima::fastcdr::MemberId(0) << data.my_long() << eprosima::fastcdr::MemberId(1) << data.my_short() << eprosima::fastcdr::MemberId(2) << data.my_string() + << eprosima::fastcdr::MemberId(3) << data.my_grandparent() ; scdr.end_serialize_type(current_state); } @@ -185,6 +189,10 @@ eProsima_user_DllExport void deserialize( dcdr >> data.my_string(); break; + case 3: + dcdr >> data.my_grandparent(); + break; + default: ret_value = false; break; @@ -304,9 +312,12 @@ eProsima_user_DllExport size_t calculate_serialized_size( data.my_string(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), - data.my_nested_element(), current_alignment); + data.my_grandparent(), current_alignment); calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(4), + data.my_nested_element(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(5), data.my_char(), current_alignment); @@ -330,8 +341,9 @@ eProsima_user_DllExport void serialize( << eprosima::fastcdr::MemberId(0) << data.my_long() << eprosima::fastcdr::MemberId(1) << data.my_short() << eprosima::fastcdr::MemberId(2) << data.my_string() - << eprosima::fastcdr::MemberId(3) << data.my_nested_element() - << eprosima::fastcdr::MemberId(4) << data.my_char() + << eprosima::fastcdr::MemberId(3) << data.my_grandparent() + << eprosima::fastcdr::MemberId(4) << data.my_nested_element() + << eprosima::fastcdr::MemberId(5) << data.my_char() ; scdr.end_serialize_type(current_state); } @@ -362,10 +374,14 @@ eProsima_user_DllExport void deserialize( break; case 3: - dcdr >> data.my_nested_element(); + dcdr >> data.my_grandparent(); break; case 4: + dcdr >> data.my_nested_element(); + break; + + case 5: dcdr >> data.my_char(); break; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx index cc538eecd3d..c1b79de458b 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/gen/struct_structTypeObjectSupport.cxx @@ -206,6 +206,34 @@ ::register_GrandparentStruct_type_identifier(type_ids_ParentStruct); CompleteStructMember member_my_string = TypeObjectUtils::build_complete_struct_member(common_my_string, detail_my_string); TypeObjectUtils::add_complete_struct_member(member_seq_ParentStruct, member_my_string); } + { + TypeIdentifierPair type_ids_my_grandparent; + ReturnCode_t return_code_my_grandparent {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_grandparent = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "GrandparentStruct", type_ids_my_grandparent); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_grandparent) + { + ::register_GrandparentStruct_type_identifier(type_ids_my_grandparent); + } + StructMemberFlag member_flags_my_grandparent = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_grandparent = 0x00000003; + bool common_my_grandparent_ec {false}; + CommonStructMember common_my_grandparent {TypeObjectUtils::build_common_struct_member(member_id_my_grandparent, member_flags_my_grandparent, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_grandparent, common_my_grandparent_ec))}; + if (!common_my_grandparent_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_grandparent member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_grandparent = "my_grandparent"; + eprosima::fastcdr::optional member_ann_builtin_my_grandparent; + ann_custom_ParentStruct.reset(); + CompleteMemberDetail detail_my_grandparent = TypeObjectUtils::build_complete_member_detail(name_my_grandparent, member_ann_builtin_my_grandparent, ann_custom_ParentStruct); + CompleteStructMember member_my_grandparent = TypeObjectUtils::build_complete_struct_member(common_my_grandparent, detail_my_grandparent); + TypeObjectUtils::add_complete_struct_member(member_seq_ParentStruct, member_my_grandparent); + } CompleteStructType struct_type_ParentStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_ParentStruct, header_ParentStruct, member_seq_ParentStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == TypeObjectUtils::build_and_register_struct_type_object(struct_type_ParentStruct, type_name_ParentStruct.to_string(), type_ids_ParentStruct)) @@ -328,7 +356,7 @@ ::register_ParentStruct_type_identifier(type_ids_StructStruct); } StructMemberFlag member_flags_my_nested_element = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_nested_element = 0x00000003; + MemberId member_id_my_nested_element = 0x00000004; bool common_my_nested_element_ec {false}; CommonStructMember common_my_nested_element {TypeObjectUtils::build_common_struct_member(member_id_my_nested_element, member_flags_my_nested_element, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_nested_element, common_my_nested_element_ec))}; if (!common_my_nested_element_ec) @@ -358,7 +386,7 @@ ::register_ParentStruct_type_identifier(type_ids_StructStruct); } StructMemberFlag member_flags_my_char = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_char = 0x00000004; + MemberId member_id_my_char = 0x00000005; bool common_my_char_ec {false}; CommonStructMember common_my_char {TypeObjectUtils::build_common_struct_member(member_id_my_char, member_flags_my_char, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_char, common_my_char_ec))}; if (!common_my_char_ec) diff --git a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl index b5c0a7ffe36..908d293f22e 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl @@ -7,6 +7,7 @@ struct ParentStruct : GrandparentStruct { short my_short; string my_string; + GrandparentStruct my_grandparent; }; struct NestedStructElement From 07acbba449553e0ec682d803531421b26ed813ca Mon Sep 17 00:00:00 2001 From: tempate Date: Tue, 9 Jul 2024 15:12:42 +0200 Subject: [PATCH 41/52] Review - Apply suggestions Signed-off-by: tempate --- .../xtypes/serializers/idl/dynamic_type_idl.hpp | 12 +++++++----- src/cpp/fastdds/xtypes/utils.cpp | 17 +++++++++++++++-- .../xtypes/serializers/idl/DynTypeIDLTests.cpp | 2 -- .../idl/types/union_struct/gen/union_struct.hpp | 10 +++++----- utils/scripts/update_generated_code_from_idl.sh | 13 +++++++++++++ 5 files changed, 40 insertions(+), 14 deletions(-) diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp index 97ea39fa0b1..80ed0d1ae8a 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.hpp @@ -224,9 +224,9 @@ ReturnCode_t node_to_idl( /////////////////////// /** - * @brief Gathers the \c element_type of the DynamicType. + * @brief Gathers the \c element_type of the @ref DynamicType. * - * @param dyn_type The DynamicType to gather the members from. + * @param dyn_type The DynamicType to gather the \c element_type from. * @param element_type The element type of the DynamicType's \c type_descriptor. */ ReturnCode_t get_element_type( @@ -234,10 +234,12 @@ ReturnCode_t get_element_type( DynamicType::_ref_type& element_type) noexcept; /** - * @brief Gathers the \c bounds of the DynamicType. + * @brief Gathers the \c bounds of the @ref DynamicType. * - * @param dyn_type The DynamicType to gather the members from. - * @param bounds The vector to store the bounds in. + * If there is a single bound of LENGTH_UNLIMITED, the bounds will be empty. + * + * @param dyn_type The DynamicType to gather the \c bounds from. + * @param bounds The bounds of the DynamicType's \c type_descriptor. */ ReturnCode_t get_bounds( const DynamicType::_ref_type& dyn_type, diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index fbcfe16fec3..277ce64d22e 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -36,17 +36,30 @@ ReturnCode_t idl_serialize( const DynamicType::_ref_type& dynamic_type, std::ostream& output) noexcept { + ReturnCode_t ret = RETCODE_OK; + // Create a tree representation of the dynamic type utilities::collections::TreeNode parent_type; - const auto ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); + ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); if (ret != RETCODE_OK) { + EPROSIMA_LOG_WARNING(XTYPES_UTILS, + "Failed to convert DynamicType to tree."); return ret; } // Serialize the tree to IDL - return dyn_type_tree_to_idl(parent_type, output); + ret = dyn_type_tree_to_idl(parent_type, output); + + if (ret != RETCODE_OK) + { + EPROSIMA_LOG_WARNING(XTYPES_UTILS, + "Failed to convert DynamicType tree to IDL."); + return ret; + } + + return RETCODE_OK; } ReturnCode_t json_serialize( diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index 0b8bcee49cb..c08baa88463 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -110,8 +110,6 @@ TEST_P(DynTypeIDLTests, to_idl) std::stringstream idl_serialization; ASSERT_EQ(idl_serialize(dyn_type, idl_serialization), RETCODE_OK); - std::cout << idl_serialization.str() << std::endl; - // Compare IDLs ASSERT_EQ(idl_file, idl_serialization.str()); } diff --git a/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp index 9301bd069c7..f8edadff464 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/union_struct/gen/union_struct.hpp @@ -318,7 +318,7 @@ class BasicUnion int64_t _second) { second_() = _second; - m__d = 2; + m__d = 32767; } /*! @@ -392,7 +392,7 @@ class BasicUnion } - int16_t m__d {2}; + int16_t m__d {32767}; union { @@ -657,7 +657,7 @@ class ComplexUnion const BasicUnion& _fourth) { fourth_() = _fourth; - m__d = 2; + m__d = 2147483647; } /*! @@ -668,7 +668,7 @@ class ComplexUnion BasicUnion&& _fourth) { fourth_() = _fourth; - m__d = 2; + m__d = 2147483647; } /*! @@ -742,7 +742,7 @@ class ComplexUnion } - int32_t m__d {2}; + int32_t m__d {2147483647}; union { diff --git a/utils/scripts/update_generated_code_from_idl.sh b/utils/scripts/update_generated_code_from_idl.sh index ad7ceff9264..8592b0edf78 100755 --- a/utils/scripts/update_generated_code_from_idl.sh +++ b/utils/scripts/update_generated_code_from_idl.sh @@ -45,6 +45,19 @@ files_needing_output_dir=( './thirdparty/dds-types-test/IDL/strings.idl|../../../test/dds-types-test' './thirdparty/dds-types-test/IDL/structures.idl|../../../test/dds-types-test' './thirdparty/dds-types-test/IDL/unions.idl|../../../test/dds-types-test' + './test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl|./gen' ) files_needing_no_typesupport=( From 0a0e9846813ef4542d42715c6c5d5e05a773bf7e Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 10 Jul 2024 11:41:21 +0200 Subject: [PATCH 42/52] Review - Sort dependencies Signed-off-by: tempate --- src/cpp/utils/collections/impl/TreeNode.ipp | 13 +- .../idl/types/alias_struct/alias_struct.idl | 7 +- .../types/alias_struct/gen/alias_struct.hpp | 81 +++------ .../alias_struct/gen/alias_structCdrAux.hpp | 2 +- .../alias_struct/gen/alias_structCdrAux.ipp | 20 +-- .../gen/alias_structPubSubTypes.hpp | 2 +- .../gen/alias_structTypeObjectSupport.cxx | 164 ++++++++---------- .../gen/alias_structTypeObjectSupport.hpp | 12 +- test/unittest/utils/TreeNodeTests.cpp | 98 +++++++++++ 9 files changed, 213 insertions(+), 186 deletions(-) diff --git a/src/cpp/utils/collections/impl/TreeNode.ipp b/src/cpp/utils/collections/impl/TreeNode.ipp index 707d6a06394..d5b6820c862 100644 --- a/src/cpp/utils/collections/impl/TreeNode.ipp +++ b/src/cpp/utils/collections/impl/TreeNode.ipp @@ -114,13 +114,16 @@ const std::list>& TreeNode::branches() const noexcept template std::list> TreeNode::all_nodes() const noexcept { - std::list> result(branches_); - for (const auto& b : branches_) + std::list> nodes; + + for (const auto& child : branches_) { - auto b_branches = b.all_nodes(); - result.splice(result.begin(), b_branches); + auto branch_nodes = child.all_nodes(); + nodes.splice(nodes.end(), branch_nodes); + nodes.push_back(child); } - return result; + + return nodes; } } /* namespace collections */ diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl index 926dd97fef6..7f1134c5528 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl @@ -1,12 +1,11 @@ +typedef unsigned long MyLong; + typedef short MyShort; typedef MyShort MyRecursiveShort; -typedef unsigned long MyLong; - struct AliasStruct { - MyRecursiveShort my_recursive_short; MyLong my_long; - MyShort my_short; + MyRecursiveShort my_recursive_short; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp index c35257a26c0..425eeb2cb86 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp @@ -49,12 +49,12 @@ #define ALIAS_STRUCT_DllAPI #endif // _WIN32 +typedef uint32_t MyLong; + typedef int16_t MyShort; typedef MyShort MyRecursiveShort; -typedef uint32_t MyLong; - /*! * @brief This class represents the structure AliasStruct defined by the user in the IDL file. * @ingroup alias_struct @@ -84,11 +84,9 @@ class AliasStruct eProsima_user_DllExport AliasStruct( const AliasStruct& x) { - m_my_recursive_short = x.m_my_recursive_short; - m_my_long = x.m_my_long; - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; } @@ -99,9 +97,8 @@ class AliasStruct eProsima_user_DllExport AliasStruct( AliasStruct&& x) noexcept { - m_my_recursive_short = x.m_my_recursive_short; m_my_long = x.m_my_long; - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; } /*! @@ -112,11 +109,9 @@ class AliasStruct const AliasStruct& x) { - m_my_recursive_short = x.m_my_recursive_short; - m_my_long = x.m_my_long; - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; return *this; } @@ -129,9 +124,8 @@ class AliasStruct AliasStruct&& x) noexcept { - m_my_recursive_short = x.m_my_recursive_short; m_my_long = x.m_my_long; - m_my_short = x.m_my_short; + m_my_recursive_short = x.m_my_recursive_short; return *this; } @@ -142,9 +136,8 @@ class AliasStruct eProsima_user_DllExport bool operator ==( const AliasStruct& x) const { - return (m_my_recursive_short == x.m_my_recursive_short && - m_my_long == x.m_my_long && - m_my_short == x.m_my_short); + return (m_my_long == x.m_my_long && + m_my_recursive_short == x.m_my_recursive_short); } /*! @@ -157,35 +150,6 @@ class AliasStruct return !(*this == x); } - /*! - * @brief This function sets a value in member my_recursive_short - * @param _my_recursive_short New value for member my_recursive_short - */ - eProsima_user_DllExport void my_recursive_short( - MyRecursiveShort _my_recursive_short) - { - m_my_recursive_short = _my_recursive_short; - } - - /*! - * @brief This function returns the value of member my_recursive_short - * @return Value of member my_recursive_short - */ - eProsima_user_DllExport MyRecursiveShort my_recursive_short() const - { - return m_my_recursive_short; - } - - /*! - * @brief This function returns a reference to member my_recursive_short - * @return Reference to member my_recursive_short - */ - eProsima_user_DllExport MyRecursiveShort& my_recursive_short() - { - return m_my_recursive_short; - } - - /*! * @brief This function sets a value in member my_long * @param _my_long New value for member my_long @@ -216,40 +180,39 @@ class AliasStruct /*! - * @brief This function sets a value in member my_short - * @param _my_short New value for member my_short + * @brief This function sets a value in member my_recursive_short + * @param _my_recursive_short New value for member my_recursive_short */ - eProsima_user_DllExport void my_short( - MyShort _my_short) + eProsima_user_DllExport void my_recursive_short( + MyRecursiveShort _my_recursive_short) { - m_my_short = _my_short; + m_my_recursive_short = _my_recursive_short; } /*! - * @brief This function returns the value of member my_short - * @return Value of member my_short + * @brief This function returns the value of member my_recursive_short + * @return Value of member my_recursive_short */ - eProsima_user_DllExport MyShort my_short() const + eProsima_user_DllExport MyRecursiveShort my_recursive_short() const { - return m_my_short; + return m_my_recursive_short; } /*! - * @brief This function returns a reference to member my_short - * @return Reference to member my_short + * @brief This function returns a reference to member my_recursive_short + * @return Reference to member my_recursive_short */ - eProsima_user_DllExport MyShort& my_short() + eProsima_user_DllExport MyRecursiveShort& my_recursive_short() { - return m_my_short; + return m_my_recursive_short; } private: - MyRecursiveShort m_my_recursive_short{0}; MyLong m_my_long{0}; - MyShort m_my_short{0}; + MyRecursiveShort m_my_recursive_short{0}; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp index 1a0316fcf80..0987d49b6d3 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp @@ -24,7 +24,7 @@ #include "alias_struct.hpp" -constexpr uint32_t AliasStruct_max_cdr_typesize {14UL}; +constexpr uint32_t AliasStruct_max_cdr_typesize {10UL}; constexpr uint32_t AliasStruct_max_key_cdr_typesize {0UL}; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp index 712da4efda5..f971642ab13 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp @@ -51,13 +51,10 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(0), - data.my_recursive_short(), current_alignment); - - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.my_long(), current_alignment); - calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), - data.my_short(), current_alignment); + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), + data.my_recursive_short(), current_alignment); calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -77,9 +74,8 @@ eProsima_user_DllExport void serialize( eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR); scdr - << eprosima::fastcdr::MemberId(0) << data.my_recursive_short() - << eprosima::fastcdr::MemberId(1) << data.my_long() - << eprosima::fastcdr::MemberId(2) << data.my_short() + << eprosima::fastcdr::MemberId(0) << data.my_long() + << eprosima::fastcdr::MemberId(1) << data.my_recursive_short() ; scdr.end_serialize_type(current_state); } @@ -98,15 +94,11 @@ eProsima_user_DllExport void deserialize( switch (mid.id) { case 0: - dcdr >> data.my_recursive_short(); - break; - - case 1: dcdr >> data.my_long(); break; - case 2: - dcdr >> data.my_short(); + case 1: + dcdr >> data.my_recursive_short(); break; default: diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp index 5989a45d815..8832ac985ff 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp @@ -37,9 +37,9 @@ Generated alias_struct is not compatible with current installed Fast DDS. Please, regenerate it with fastddsgen. #endif // GEN_API_VER +typedef uint32_t MyLong; typedef int16_t MyShort; typedef MyShort MyRecursiveShort; -typedef uint32_t MyLong; /*! * @brief This class represents the TopicDataType of the type AliasStruct defined by the user in the IDL file. diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx index ed1cbdc2148..5b3fafe1272 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx @@ -38,6 +38,56 @@ using namespace eprosima::fastdds::dds::xtypes; +void register_MyLong_type_identifier( + TypeIdentifierPair& type_ids_MyLong) +{ + ReturnCode_t return_code_MyLong {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyLong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyLong", type_ids_MyLong); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) + { + AliasTypeFlag alias_flags_MyLong = 0; + QualifiedTypeName type_name_MyLong = "MyLong"; + eprosima::fastcdr::optional type_ann_builtin_MyLong; + eprosima::fastcdr::optional ann_custom_MyLong; + CompleteTypeDetail detail_MyLong = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyLong, ann_custom_MyLong, type_name_MyLong.to_string()); + CompleteAliasHeader header_MyLong = TypeObjectUtils::build_complete_alias_header(detail_MyLong); + AliasMemberFlag related_flags_MyLong = 0; + return_code_MyLong = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_uint32_t", type_ids_MyLong); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyLong related TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool common_MyLong_ec {false}; + CommonAliasBody common_MyLong {TypeObjectUtils::build_common_alias_body(related_flags_MyLong, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyLong, common_MyLong_ec))}; + if (!common_MyLong_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyLong related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyLong; + ann_custom_MyLong.reset(); + CompleteAliasBody body_MyLong = TypeObjectUtils::build_complete_alias_body(common_MyLong, + member_ann_builtin_MyLong, ann_custom_MyLong); + CompleteAliasType alias_type_MyLong = TypeObjectUtils::build_complete_alias_type(alias_flags_MyLong, + header_MyLong, body_MyLong); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyLong, + type_name_MyLong.to_string(), type_ids_MyLong)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyLong already registered in TypeObjectRegistry for a different type."); + } + } +} + void register_MyShort_type_identifier( TypeIdentifierPair& type_ids_MyShort) { @@ -136,56 +186,6 @@ void register_MyRecursiveShort_type_identifier( } } -void register_MyLong_type_identifier( - TypeIdentifierPair& type_ids_MyLong) -{ - ReturnCode_t return_code_MyLong {eprosima::fastdds::dds::RETCODE_OK}; - return_code_MyLong = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyLong", type_ids_MyLong); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) - { - AliasTypeFlag alias_flags_MyLong = 0; - QualifiedTypeName type_name_MyLong = "MyLong"; - eprosima::fastcdr::optional type_ann_builtin_MyLong; - eprosima::fastcdr::optional ann_custom_MyLong; - CompleteTypeDetail detail_MyLong = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyLong, ann_custom_MyLong, type_name_MyLong.to_string()); - CompleteAliasHeader header_MyLong = TypeObjectUtils::build_complete_alias_header(detail_MyLong); - AliasMemberFlag related_flags_MyLong = 0; - return_code_MyLong = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "_uint32_t", type_ids_MyLong); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyLong) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "MyLong related TypeIdentifier unknown to TypeObjectRegistry."); - return; - } - bool common_MyLong_ec {false}; - CommonAliasBody common_MyLong {TypeObjectUtils::build_common_alias_body(related_flags_MyLong, - TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyLong, common_MyLong_ec))}; - if (!common_MyLong_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyLong related TypeIdentifier inconsistent."); - return; - } - eprosima::fastcdr::optional member_ann_builtin_MyLong; - ann_custom_MyLong.reset(); - CompleteAliasBody body_MyLong = TypeObjectUtils::build_complete_alias_body(common_MyLong, - member_ann_builtin_MyLong, ann_custom_MyLong); - CompleteAliasType alias_type_MyLong = TypeObjectUtils::build_complete_alias_type(alias_flags_MyLong, - header_MyLong, body_MyLong); - if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == - TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyLong, - type_name_MyLong.to_string(), type_ids_MyLong)) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, - "MyLong already registered in TypeObjectRegistry for a different type."); - } - } -} - // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method void register_AliasStruct_type_identifier( TypeIdentifierPair& type_ids_AliasStruct) @@ -206,34 +206,6 @@ void register_AliasStruct_type_identifier( CompleteStructHeader header_AliasStruct; header_AliasStruct = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_AliasStruct); CompleteStructMemberSeq member_seq_AliasStruct; - { - TypeIdentifierPair type_ids_my_recursive_short; - ReturnCode_t return_code_my_recursive_short {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_recursive_short = - eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyRecursiveShort", type_ids_my_recursive_short); - - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_short) - { - ::register_MyRecursiveShort_type_identifier(type_ids_my_recursive_short); - } - StructMemberFlag member_flags_my_recursive_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, - false, false, false, false); - MemberId member_id_my_recursive_short = 0x00000000; - bool common_my_recursive_short_ec {false}; - CommonStructMember common_my_recursive_short {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_short, member_flags_my_recursive_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_short, common_my_recursive_short_ec))}; - if (!common_my_recursive_short_ec) - { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_short member TypeIdentifier inconsistent."); - return; - } - MemberName name_my_recursive_short = "my_recursive_short"; - eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; - ann_custom_AliasStruct.reset(); - CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_AliasStruct); - CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); - TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); - } { TypeIdentifierPair type_ids_my_long; ReturnCode_t return_code_my_long {eprosima::fastdds::dds::RETCODE_OK}; @@ -247,7 +219,7 @@ void register_AliasStruct_type_identifier( } StructMemberFlag member_flags_my_long = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_long = 0x00000001; + MemberId member_id_my_long = 0x00000000; bool common_my_long_ec {false}; CommonStructMember common_my_long {TypeObjectUtils::build_common_struct_member(member_id_my_long, member_flags_my_long, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_long, common_my_long_ec))}; if (!common_my_long_ec) @@ -263,32 +235,32 @@ void register_AliasStruct_type_identifier( TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_long); } { - TypeIdentifierPair type_ids_my_short; - ReturnCode_t return_code_my_short {eprosima::fastdds::dds::RETCODE_OK}; - return_code_my_short = + TypeIdentifierPair type_ids_my_recursive_short; + ReturnCode_t return_code_my_recursive_short {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_recursive_short = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( - "MyShort", type_ids_my_short); + "MyRecursiveShort", type_ids_my_recursive_short); - if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_short) + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_short) { - ::register_MyShort_type_identifier(type_ids_my_short); + ::register_MyRecursiveShort_type_identifier(type_ids_my_recursive_short); } - StructMemberFlag member_flags_my_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + StructMemberFlag member_flags_my_recursive_short = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, false, false, false, false); - MemberId member_id_my_short = 0x00000002; - bool common_my_short_ec {false}; - CommonStructMember common_my_short {TypeObjectUtils::build_common_struct_member(member_id_my_short, member_flags_my_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_short, common_my_short_ec))}; - if (!common_my_short_ec) + MemberId member_id_my_recursive_short = 0x00000001; + bool common_my_recursive_short_ec {false}; + CommonStructMember common_my_recursive_short {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_short, member_flags_my_recursive_short, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_short, common_my_recursive_short_ec))}; + if (!common_my_recursive_short_ec) { - EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_short member TypeIdentifier inconsistent."); + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_short member TypeIdentifier inconsistent."); return; } - MemberName name_my_short = "my_short"; - eprosima::fastcdr::optional member_ann_builtin_my_short; + MemberName name_my_recursive_short = "my_recursive_short"; + eprosima::fastcdr::optional member_ann_builtin_my_recursive_short; ann_custom_AliasStruct.reset(); - CompleteMemberDetail detail_my_short = TypeObjectUtils::build_complete_member_detail(name_my_short, member_ann_builtin_my_short, ann_custom_AliasStruct); - CompleteStructMember member_my_short = TypeObjectUtils::build_complete_struct_member(common_my_short, detail_my_short); - TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_short); + CompleteMemberDetail detail_my_recursive_short = TypeObjectUtils::build_complete_member_detail(name_my_recursive_short, member_ann_builtin_my_recursive_short, ann_custom_AliasStruct); + CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); } CompleteStructType struct_type_AliasStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AliasStruct, header_AliasStruct, member_seq_AliasStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp index 19b43e90e8b..17046bf8698 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp @@ -38,7 +38,7 @@ #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC /** - * @brief Register MyShort related TypeIdentifier. + * @brief Register MyLong related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -47,12 +47,12 @@ * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyShort_type_identifier( +eProsima_user_DllExport void register_MyLong_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register MyRecursiveShort related TypeIdentifier. + * @brief Register MyShort related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -61,12 +61,12 @@ eProsima_user_DllExport void register_MyShort_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( +eProsima_user_DllExport void register_MyShort_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); /** - * @brief Register MyLong related TypeIdentifier. + * @brief Register MyRecursiveShort related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is * indirectly registered as well. @@ -75,7 +75,7 @@ eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. * Invalid TypeIdentifier is returned in case of error. */ -eProsima_user_DllExport void register_MyLong_type_identifier( +eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); diff --git a/test/unittest/utils/TreeNodeTests.cpp b/test/unittest/utils/TreeNodeTests.cpp index 3a820286958..28f52b397a0 100644 --- a/test/unittest/utils/TreeNodeTests.cpp +++ b/test/unittest/utils/TreeNodeTests.cpp @@ -13,6 +13,7 @@ // limitations under the License. #include +#include #include #include @@ -172,10 +173,29 @@ TEST(TreeNodeTests, many_shallow_branches) const auto tree_nodes = root.all_nodes(); ASSERT_EQ(tree_nodes.size(), NODE_COUNT - 1); + // Verify the node order + static const std::array NODES_ORDER{"1", "2", "3", "4", "5"}; + int i = 0; + + for (const auto& node : tree_nodes) + { + ASSERT_EQ(node.info.name, NODES_ORDER[i]); + i++; + } + // Verify the branch count const auto tree_branches = root.branches(); ASSERT_EQ(tree_branches.size(), NODE_COUNT - 1); + // Verify the branch order + i = 0; + + for (const auto& child : tree_branches) + { + ASSERT_EQ(child.info.name, NODES_ORDER[i]); + i++; + } + // Verify that every branch is a leaf for (const auto& branch : tree_branches) { @@ -183,6 +203,84 @@ TEST(TreeNodeTests, many_shallow_branches) } } +/** + * @brief Test that a tree can support a binary tree. + * + * ┌───0───┐ + * │ │ + * ▼ ▼ + * ┌──1──┐ ┌──2──┐ + * │ │ │ │ + * ▼ ▼ ▼ ▼ + * 3 4 5 6 + */ +TEST(TreeNodeTests, binary_tree) +{ + constexpr auto NODE_COUNT = 7; + + std::vector nodes; + std::vector> trees; + + // Create the nodes and the trees + for (int i = 0; i < NODE_COUNT; i++) + { + nodes.emplace_back(std::to_string(i)); + trees.emplace_back(nodes[i]); + } + + // Build the tree + trees[1].add_branch(trees[3]); + trees[1].add_branch(trees[4]); + + trees[2].add_branch(trees[5]); + trees[2].add_branch(trees[6]); + + trees[0].add_branch(trees[1]); + trees[0].add_branch(trees[2]); + + const auto& root = trees[0]; + + // Verify the depth + const auto tree_depth = root.depth(); + ASSERT_EQ(tree_depth, 2); + + // Verify the node count + const auto tree_nodes = root.all_nodes(); + ASSERT_EQ(tree_nodes.size(), NODE_COUNT - 1); + + // Verify the node order + const std::array NODES_ORDER{"3", "4", "1", "5", "6", "2"}; + int i = 0; + + for (const auto& node : tree_nodes) + { + ASSERT_EQ(node.info.name, NODES_ORDER[i]); + i++; + } + + // Verify the branch count + const auto tree_branches = root.branches(); + ASSERT_EQ(tree_branches.size(), 2); + + // Verify the branch order + ASSERT_EQ(tree_branches.front().info.name, "1"); + ASSERT_EQ(tree_branches.back().info.name, "2"); + + // Verify that every branch is not a leaf + for (const auto& branch : tree_branches) + { + // Verify the branch count + const auto branch_branches = branch.branches(); + ASSERT_EQ(branch_branches.size(), 2); + + // Verify that every branch is a leaf + for (const auto& branch_branch : branch_branches) + { + ASSERT_TRUE(branch_branch.leaf()); + } + } +} + int main( int argc, From 169019f71ae341fdd0248268e545aa2cf835e1cf Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 10 Jul 2024 12:43:02 +0200 Subject: [PATCH 43/52] Fix - Declaration of `bits` hides previous local declaration Signed-off-by: tempate --- .../serializers/idl/dynamic_type_idl.cpp | 26 ++++++++++++------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index c7b804a9862..d5d89816d84 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -772,6 +772,17 @@ ReturnCode_t bitset_to_idl( idl << "bitset " << node.info.type_kind_name << TYPE_OPENING; + // Find the bits that each bitfield occupies + BoundSeq bounds; + ret = get_bounds(node.info.dynamic_type, bounds); + + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting bounds of " << node.info.dynamic_type->get_name().to_string() << "."); + return ret; + } + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; ret = node.info.dynamic_type->get_descriptor(type_descriptor); @@ -781,9 +792,6 @@ ReturnCode_t bitset_to_idl( return ret; } - // Find the bits that each bitfield occupies - const auto bits = type_descriptor->bound(); - std::uint32_t bits_set = 0; for (std::uint32_t index = 0; index < node.info.dynamic_type->get_member_count(); index++) @@ -803,13 +811,13 @@ ReturnCode_t bitset_to_idl( if (id > bits_set) { // If the id is higher than the bits set, there must have been an empty bitfield (i.e. a gap) - const auto bits = id - bits_set; - bits_set += bits; + const auto gap = id - bits_set; + bits_set += gap; - idl << TAB_SEPARATOR << "bitfield<" << std::to_string(bits) << ">;\n"; + idl << TAB_SEPARATOR << "bitfield<" << std::to_string(gap) << ">;\n"; } - idl << TAB_SEPARATOR << "bitfield<" << std::to_string(bits[index]); + idl << TAB_SEPARATOR << "bitfield<" << std::to_string(bounds[index]); MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; ret = member->get_descriptor(member_descriptor); @@ -821,7 +829,7 @@ ReturnCode_t bitset_to_idl( } TypeKind default_type_kind; - ret = get_default_type_kind(bits[index], default_type_kind); + ret = get_default_type_kind(bounds[index], default_type_kind); if (RETCODE_OK != ret) { @@ -841,7 +849,7 @@ ReturnCode_t bitset_to_idl( idl << "> " << member->get_name().to_string() << ";\n"; - bits_set += bits[index]; + bits_set += bounds[index]; } // Close definition From 1a49fa601dcb8794b9beab226d4ada609b3a7a19 Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 10 Jul 2024 12:56:31 +0200 Subject: [PATCH 44/52] Fix - Linking issues Signed-off-by: tempate --- test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index 0923e57dd72..b71a8897ad9 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -66,8 +66,7 @@ configure_file( COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE - DynTypeIDLTests.cpp - ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/xtypes/utils.cpp) + DynTypeIDLTests.cpp) file(GLOB DATATYPE_SOURCES "types/**/gen/*.cxx") From 9a5a3a07a51ba6fb4040746038f6ac83e448902b Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 10 Jul 2024 14:38:37 +0200 Subject: [PATCH 45/52] Fix - Declaration of `info` hides member Signed-off-by: tempate --- src/cpp/utils/collections/TreeNode.hpp | 8 ++++---- src/cpp/utils/collections/impl/TreeNode.ipp | 16 ++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/cpp/utils/collections/TreeNode.hpp b/src/cpp/utils/collections/TreeNode.hpp index ce3426dbefb..97001e58868 100644 --- a/src/cpp/utils/collections/TreeNode.hpp +++ b/src/cpp/utils/collections/TreeNode.hpp @@ -35,9 +35,9 @@ struct Node Node(); Node( - const Info& info); + const Info& inner_info); Node( - Info&& info); + Info&& inner_info); template Node( @@ -57,9 +57,9 @@ class TreeNode : public Node using Node::Node; void add_branch( - const Info& info); + const Info& inner_info); void add_branch( - Info&& info); + Info&& inner_info); void add_branch( const TreeNode& node); void add_branch( diff --git a/src/cpp/utils/collections/impl/TreeNode.ipp b/src/cpp/utils/collections/impl/TreeNode.ipp index d5b6820c862..843295aa86d 100644 --- a/src/cpp/utils/collections/impl/TreeNode.ipp +++ b/src/cpp/utils/collections/impl/TreeNode.ipp @@ -34,16 +34,16 @@ Node::Node() template Node::Node( - const Info& info) - : info(info) + const Info& inner_info) + : info(inner_info) { // Do nothing } template Node::Node( - Info&& info) - : info(std::move(info)) + Info&& inner_info) + : info(std::move(inner_info)) { // Do nothing } @@ -59,16 +59,16 @@ Node::Node( template void TreeNode::add_branch( - const Info& info) + const Info& inner_info) { - branches_.push_back(TreeNode(info)); + branches_.push_back(TreeNode(inner_info)); } template void TreeNode::add_branch( - Info&& info) + Info&& inner_info) { - branches_.push_back(TreeNode(std::move(info))); + branches_.push_back(TreeNode(std::move(inner_info))); } template From 802a6d96b40e7b44f3fad20feeab4db3c10398d3 Mon Sep 17 00:00:00 2001 From: tempate Date: Wed, 10 Jul 2024 16:40:11 +0200 Subject: [PATCH 46/52] Fix - to_upper Signed-off-by: tempate --- src/cpp/utils/UnitsParser.hpp | 2 +- test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt | 3 ++- .../dds/xtypes/serializers/idl/DynTypeIDLTests.cpp | 8 ++++++-- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/cpp/utils/UnitsParser.hpp b/src/cpp/utils/UnitsParser.hpp index d04e4f6625d..2101d3bc0ab 100644 --- a/src/cpp/utils/UnitsParser.hpp +++ b/src/cpp/utils/UnitsParser.hpp @@ -32,7 +32,7 @@ namespace utils { * * @param [in] st String to convert */ -inline void to_uppercase( +void to_uppercase( std::string& st) noexcept; /** diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index b71a8897ad9..60220090bf4 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -66,7 +66,8 @@ configure_file( COPYONLY) set(RESOURCEDYNTYPETOIDLTESTS_SOURCE - DynTypeIDLTests.cpp) + DynTypeIDLTests.cpp + ${PROJECT_SOURCE_DIR}/src/cpp/utils/UnitsParser.cpp) file(GLOB DATATYPE_SOURCES "types/**/gen/*.cxx") diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index c08baa88463..4d103f042ab 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -19,6 +19,8 @@ #include +#include + #include #include #include @@ -58,7 +60,7 @@ class DynTypeIDLTests : public ::testing::TestWithParam std::string camel_case; bool to_upper = true; - for (char ch : snake_case) + for (const auto& ch : snake_case) { if (ch == '_') { @@ -66,7 +68,9 @@ class DynTypeIDLTests : public ::testing::TestWithParam } else if (to_upper) { - camel_case += std::toupper(ch); + std::string ch_str(1, ch); + utils::to_uppercase(ch_str); + camel_case += ch_str; to_upper = false; } else From 890c28581013a16537a93dac5110049e317d7800 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 08:56:59 +0200 Subject: [PATCH 47/52] Review - Apply suggestions Signed-off-by: tempate --- include/fastdds/dds/xtypes/utils.hpp | 2 +- src/cpp/fastdds/xtypes/utils.cpp | 10 +- .../dds/xtypes/serializers/idl/CMakeLists.txt | 70 ++------ .../idl/types/alias_struct/alias_struct.idl | 6 + .../types/alias_struct/gen/alias_struct.hpp | 80 ++++++++- .../alias_struct/gen/alias_structCdrAux.hpp | 4 +- .../alias_struct/gen/alias_structCdrAux.ipp | 16 ++ .../gen/alias_structPubSubTypes.hpp | 2 + .../gen/alias_structTypeObjectSupport.cxx | 154 ++++++++++++++++++ .../gen/alias_structTypeObjectSupport.hpp | 28 ++++ 10 files changed, 312 insertions(+), 60 deletions(-) diff --git a/include/fastdds/dds/xtypes/utils.hpp b/include/fastdds/dds/xtypes/utils.hpp index e3a01a43483..48706c9e9a1 100644 --- a/include/fastdds/dds/xtypes/utils.hpp +++ b/include/fastdds/dds/xtypes/utils.hpp @@ -41,7 +41,7 @@ enum class DynamicDataJsonFormat * @brief Serializes a @ref DynamicType into its IDL representation. * * @param [in] dynamic_type The @ref DynamicType to serialize. - * @param [in,out] output The IDL representation. + * @param [in,out] output \c std::ostream reference containing the IDL representation. * @retval RETCODE_OK when serialization fully succeeds, and inner (member serialization) failing code otherwise. */ FASTDDS_EXPORTED_API ReturnCode_t idl_serialize( diff --git a/src/cpp/fastdds/xtypes/utils.cpp b/src/cpp/fastdds/xtypes/utils.cpp index 277ce64d22e..657eb9c8cd7 100644 --- a/src/cpp/fastdds/xtypes/utils.cpp +++ b/src/cpp/fastdds/xtypes/utils.cpp @@ -39,22 +39,22 @@ ReturnCode_t idl_serialize( ReturnCode_t ret = RETCODE_OK; // Create a tree representation of the dynamic type - utilities::collections::TreeNode parent_type; - ret = dyn_type_to_tree(dynamic_type, "PARENT", parent_type); + utilities::collections::TreeNode root; + ret = dyn_type_to_tree(dynamic_type, "ROOT", root); if (ret != RETCODE_OK) { - EPROSIMA_LOG_WARNING(XTYPES_UTILS, + EPROSIMA_LOG_ERROR(XTYPES_UTILS, "Failed to convert DynamicType to tree."); return ret; } // Serialize the tree to IDL - ret = dyn_type_tree_to_idl(parent_type, output); + ret = dyn_type_tree_to_idl(root, output); if (ret != RETCODE_OK) { - EPROSIMA_LOG_WARNING(XTYPES_UTILS, + EPROSIMA_LOG_ERROR(XTYPES_UTILS, "Failed to convert DynamicType tree to IDL."); return ret; } diff --git a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt index 60220090bf4..2bf25855870 100644 --- a/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/idl/CMakeLists.txt @@ -12,58 +12,24 @@ # See the License for the specific language governing permissions and # limitations under the License. -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/alias_struct/alias_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/alias_struct/alias_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/array_struct/array_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/array_struct/array_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/bitmask_struct/bitmask_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/bitmask_struct/bitmask_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/bitset_struct/bitset_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/bitset_struct/bitset_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/enum_struct/enum_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/enum_struct/enum_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/extensibility_struct/extensibility_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/extensibility_struct/extensibility_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/key_struct/key_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/key_struct/key_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/map_struct/map_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/map_struct/map_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/primitives_struct/primitives_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/primitives_struct/primitives_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/sequence_struct/sequence_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/sequence_struct/sequence_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/string_struct/string_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/string_struct/string_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/struct_struct/struct_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/struct_struct/struct_struct.idl - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/union_struct/union_struct.idl - ${CMAKE_CURRENT_BINARY_DIR}/types/union_struct/union_struct.idl - COPYONLY) +# Recursively find all .idl files in the types directory +file(GLOB_RECURSE IDL_FILES ${CMAKE_CURRENT_SOURCE_DIR}/types/*.idl) + +# Iterate over each .idl file found +foreach(IDL_FILE ${IDL_FILES}) + # Get the relative path of the .idl file + file(RELATIVE_PATH RELATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${IDL_FILE}) + + # Determine the destination directory + set(DEST_DIR ${CMAKE_CURRENT_BINARY_DIR}/${RELATIVE_PATH}) + get_filename_component(DEST_DIR ${DEST_DIR} DIRECTORY) + + # Ensure the destination directory exists + file(MAKE_DIRECTORY ${DEST_DIR}) + + # Copy the .idl file to the destination directory + configure_file(${IDL_FILE} ${DEST_DIR} COPYONLY) +endforeach() set(RESOURCEDYNTYPETOIDLTESTS_SOURCE DynTypeIDLTests.cpp diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl index 7f1134c5528..bee9e3e2028 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl @@ -4,8 +4,14 @@ typedef short MyShort; typedef MyShort MyRecursiveShort; +typedef boolean MyBoolean; + +typedef MyBoolean MyRecursiveBoolean; + struct AliasStruct { MyLong my_long; MyRecursiveShort my_recursive_short; + MyRecursiveBoolean my_recursive_boolean; + MyBoolean my_boolean; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp index 425eeb2cb86..5eb80d5f9b4 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_struct.hpp @@ -55,6 +55,10 @@ typedef int16_t MyShort; typedef MyShort MyRecursiveShort; +typedef bool MyBoolean; + +typedef MyBoolean MyRecursiveBoolean; + /*! * @brief This class represents the structure AliasStruct defined by the user in the IDL file. * @ingroup alias_struct @@ -88,6 +92,10 @@ class AliasStruct m_my_recursive_short = x.m_my_recursive_short; + m_my_recursive_boolean = x.m_my_recursive_boolean; + + m_my_boolean = x.m_my_boolean; + } /*! @@ -99,6 +107,8 @@ class AliasStruct { m_my_long = x.m_my_long; m_my_recursive_short = x.m_my_recursive_short; + m_my_recursive_boolean = x.m_my_recursive_boolean; + m_my_boolean = x.m_my_boolean; } /*! @@ -113,6 +123,10 @@ class AliasStruct m_my_recursive_short = x.m_my_recursive_short; + m_my_recursive_boolean = x.m_my_recursive_boolean; + + m_my_boolean = x.m_my_boolean; + return *this; } @@ -126,6 +140,8 @@ class AliasStruct m_my_long = x.m_my_long; m_my_recursive_short = x.m_my_recursive_short; + m_my_recursive_boolean = x.m_my_recursive_boolean; + m_my_boolean = x.m_my_boolean; return *this; } @@ -137,7 +153,9 @@ class AliasStruct const AliasStruct& x) const { return (m_my_long == x.m_my_long && - m_my_recursive_short == x.m_my_recursive_short); + m_my_recursive_short == x.m_my_recursive_short && + m_my_recursive_boolean == x.m_my_recursive_boolean && + m_my_boolean == x.m_my_boolean); } /*! @@ -208,11 +226,71 @@ class AliasStruct } + /*! + * @brief This function sets a value in member my_recursive_boolean + * @param _my_recursive_boolean New value for member my_recursive_boolean + */ + eProsima_user_DllExport void my_recursive_boolean( + MyRecursiveBoolean _my_recursive_boolean) + { + m_my_recursive_boolean = _my_recursive_boolean; + } + + /*! + * @brief This function returns the value of member my_recursive_boolean + * @return Value of member my_recursive_boolean + */ + eProsima_user_DllExport MyRecursiveBoolean my_recursive_boolean() const + { + return m_my_recursive_boolean; + } + + /*! + * @brief This function returns a reference to member my_recursive_boolean + * @return Reference to member my_recursive_boolean + */ + eProsima_user_DllExport MyRecursiveBoolean& my_recursive_boolean() + { + return m_my_recursive_boolean; + } + + + /*! + * @brief This function sets a value in member my_boolean + * @param _my_boolean New value for member my_boolean + */ + eProsima_user_DllExport void my_boolean( + MyBoolean _my_boolean) + { + m_my_boolean = _my_boolean; + } + + /*! + * @brief This function returns the value of member my_boolean + * @return Value of member my_boolean + */ + eProsima_user_DllExport MyBoolean my_boolean() const + { + return m_my_boolean; + } + + /*! + * @brief This function returns a reference to member my_boolean + * @return Reference to member my_boolean + */ + eProsima_user_DllExport MyBoolean& my_boolean() + { + return m_my_boolean; + } + + private: MyLong m_my_long{0}; MyRecursiveShort m_my_recursive_short{0}; + MyRecursiveBoolean m_my_recursive_boolean{false}; + MyBoolean m_my_boolean{false}; }; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp index 0987d49b6d3..d66f04beecd 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.hpp @@ -24,13 +24,15 @@ #include "alias_struct.hpp" -constexpr uint32_t AliasStruct_max_cdr_typesize {10UL}; +constexpr uint32_t AliasStruct_max_cdr_typesize {12UL}; constexpr uint32_t AliasStruct_max_key_cdr_typesize {0UL}; + + namespace eprosima { namespace fastcdr { diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp index f971642ab13..1ef275df173 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structCdrAux.ipp @@ -56,6 +56,12 @@ eProsima_user_DllExport size_t calculate_serialized_size( calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(1), data.my_recursive_short(), current_alignment); + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(2), + data.my_recursive_boolean(), current_alignment); + + calculated_size += calculator.calculate_member_serialized_size(eprosima::fastcdr::MemberId(3), + data.my_boolean(), current_alignment); + calculated_size += calculator.end_calculate_type_serialized_size(previous_encoding, current_alignment); @@ -76,6 +82,8 @@ eProsima_user_DllExport void serialize( scdr << eprosima::fastcdr::MemberId(0) << data.my_long() << eprosima::fastcdr::MemberId(1) << data.my_recursive_short() + << eprosima::fastcdr::MemberId(2) << data.my_recursive_boolean() + << eprosima::fastcdr::MemberId(3) << data.my_boolean() ; scdr.end_serialize_type(current_state); } @@ -101,6 +109,14 @@ eProsima_user_DllExport void deserialize( dcdr >> data.my_recursive_short(); break; + case 2: + dcdr >> data.my_recursive_boolean(); + break; + + case 3: + dcdr >> data.my_boolean(); + break; + default: ret_value = false; break; diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp index 8832ac985ff..efef4820a40 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structPubSubTypes.hpp @@ -40,6 +40,8 @@ typedef uint32_t MyLong; typedef int16_t MyShort; typedef MyShort MyRecursiveShort; +typedef bool MyBoolean; +typedef MyBoolean MyRecursiveBoolean; /*! * @brief This class represents the TopicDataType of the type AliasStruct defined by the user in the IDL file. diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx index 5b3fafe1272..f285da0197f 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.cxx @@ -186,6 +186,104 @@ void register_MyRecursiveShort_type_identifier( } } +void register_MyBoolean_type_identifier( + TypeIdentifierPair& type_ids_MyBoolean) +{ + ReturnCode_t return_code_MyBoolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyBoolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyBoolean", type_ids_MyBoolean); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyBoolean) + { + AliasTypeFlag alias_flags_MyBoolean = 0; + QualifiedTypeName type_name_MyBoolean = "MyBoolean"; + eprosima::fastcdr::optional type_ann_builtin_MyBoolean; + eprosima::fastcdr::optional ann_custom_MyBoolean; + CompleteTypeDetail detail_MyBoolean = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyBoolean, ann_custom_MyBoolean, type_name_MyBoolean.to_string()); + CompleteAliasHeader header_MyBoolean = TypeObjectUtils::build_complete_alias_header(detail_MyBoolean); + AliasMemberFlag related_flags_MyBoolean = 0; + return_code_MyBoolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "_bool", type_ids_MyBoolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyBoolean) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyBoolean related TypeIdentifier unknown to TypeObjectRegistry."); + return; + } + bool common_MyBoolean_ec {false}; + CommonAliasBody common_MyBoolean {TypeObjectUtils::build_common_alias_body(related_flags_MyBoolean, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyBoolean, common_MyBoolean_ec))}; + if (!common_MyBoolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyBoolean related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyBoolean; + ann_custom_MyBoolean.reset(); + CompleteAliasBody body_MyBoolean = TypeObjectUtils::build_complete_alias_body(common_MyBoolean, + member_ann_builtin_MyBoolean, ann_custom_MyBoolean); + CompleteAliasType alias_type_MyBoolean = TypeObjectUtils::build_complete_alias_type(alias_flags_MyBoolean, + header_MyBoolean, body_MyBoolean); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyBoolean, + type_name_MyBoolean.to_string(), type_ids_MyBoolean)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyBoolean already registered in TypeObjectRegistry for a different type."); + } + } +} + +void register_MyRecursiveBoolean_type_identifier( + TypeIdentifierPair& type_ids_MyRecursiveBoolean) +{ + ReturnCode_t return_code_MyRecursiveBoolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_MyRecursiveBoolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyRecursiveBoolean", type_ids_MyRecursiveBoolean); + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveBoolean) + { + AliasTypeFlag alias_flags_MyRecursiveBoolean = 0; + QualifiedTypeName type_name_MyRecursiveBoolean = "MyRecursiveBoolean"; + eprosima::fastcdr::optional type_ann_builtin_MyRecursiveBoolean; + eprosima::fastcdr::optional ann_custom_MyRecursiveBoolean; + CompleteTypeDetail detail_MyRecursiveBoolean = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_MyRecursiveBoolean, ann_custom_MyRecursiveBoolean, type_name_MyRecursiveBoolean.to_string()); + CompleteAliasHeader header_MyRecursiveBoolean = TypeObjectUtils::build_complete_alias_header(detail_MyRecursiveBoolean); + AliasMemberFlag related_flags_MyRecursiveBoolean = 0; + return_code_MyRecursiveBoolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyBoolean", type_ids_MyRecursiveBoolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_MyRecursiveBoolean) + { + ::register_MyBoolean_type_identifier(type_ids_MyRecursiveBoolean); + } + bool common_MyRecursiveBoolean_ec {false}; + CommonAliasBody common_MyRecursiveBoolean {TypeObjectUtils::build_common_alias_body(related_flags_MyRecursiveBoolean, + TypeObjectUtils::retrieve_complete_type_identifier(type_ids_MyRecursiveBoolean, common_MyRecursiveBoolean_ec))}; + if (!common_MyRecursiveBoolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "MyRecursiveBoolean related TypeIdentifier inconsistent."); + return; + } + eprosima::fastcdr::optional member_ann_builtin_MyRecursiveBoolean; + ann_custom_MyRecursiveBoolean.reset(); + CompleteAliasBody body_MyRecursiveBoolean = TypeObjectUtils::build_complete_alias_body(common_MyRecursiveBoolean, + member_ann_builtin_MyRecursiveBoolean, ann_custom_MyRecursiveBoolean); + CompleteAliasType alias_type_MyRecursiveBoolean = TypeObjectUtils::build_complete_alias_type(alias_flags_MyRecursiveBoolean, + header_MyRecursiveBoolean, body_MyRecursiveBoolean); + if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == + TypeObjectUtils::build_and_register_alias_type_object(alias_type_MyRecursiveBoolean, + type_name_MyRecursiveBoolean.to_string(), type_ids_MyRecursiveBoolean)) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, + "MyRecursiveBoolean already registered in TypeObjectRegistry for a different type."); + } + } +} + // TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method void register_AliasStruct_type_identifier( TypeIdentifierPair& type_ids_AliasStruct) @@ -262,6 +360,62 @@ void register_AliasStruct_type_identifier( CompleteStructMember member_my_recursive_short = TypeObjectUtils::build_complete_struct_member(common_my_recursive_short, detail_my_recursive_short); TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_short); } + { + TypeIdentifierPair type_ids_my_recursive_boolean; + ReturnCode_t return_code_my_recursive_boolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_recursive_boolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyRecursiveBoolean", type_ids_my_recursive_boolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_recursive_boolean) + { + ::register_MyRecursiveBoolean_type_identifier(type_ids_my_recursive_boolean); + } + StructMemberFlag member_flags_my_recursive_boolean = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_recursive_boolean = 0x00000002; + bool common_my_recursive_boolean_ec {false}; + CommonStructMember common_my_recursive_boolean {TypeObjectUtils::build_common_struct_member(member_id_my_recursive_boolean, member_flags_my_recursive_boolean, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_recursive_boolean, common_my_recursive_boolean_ec))}; + if (!common_my_recursive_boolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_recursive_boolean member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_recursive_boolean = "my_recursive_boolean"; + eprosima::fastcdr::optional member_ann_builtin_my_recursive_boolean; + ann_custom_AliasStruct.reset(); + CompleteMemberDetail detail_my_recursive_boolean = TypeObjectUtils::build_complete_member_detail(name_my_recursive_boolean, member_ann_builtin_my_recursive_boolean, ann_custom_AliasStruct); + CompleteStructMember member_my_recursive_boolean = TypeObjectUtils::build_complete_struct_member(common_my_recursive_boolean, detail_my_recursive_boolean); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_recursive_boolean); + } + { + TypeIdentifierPair type_ids_my_boolean; + ReturnCode_t return_code_my_boolean {eprosima::fastdds::dds::RETCODE_OK}; + return_code_my_boolean = + eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers( + "MyBoolean", type_ids_my_boolean); + + if (eprosima::fastdds::dds::RETCODE_OK != return_code_my_boolean) + { + ::register_MyBoolean_type_identifier(type_ids_my_boolean); + } + StructMemberFlag member_flags_my_boolean = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD, + false, false, false, false); + MemberId member_id_my_boolean = 0x00000003; + bool common_my_boolean_ec {false}; + CommonStructMember common_my_boolean {TypeObjectUtils::build_common_struct_member(member_id_my_boolean, member_flags_my_boolean, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_my_boolean, common_my_boolean_ec))}; + if (!common_my_boolean_ec) + { + EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure my_boolean member TypeIdentifier inconsistent."); + return; + } + MemberName name_my_boolean = "my_boolean"; + eprosima::fastcdr::optional member_ann_builtin_my_boolean; + ann_custom_AliasStruct.reset(); + CompleteMemberDetail detail_my_boolean = TypeObjectUtils::build_complete_member_detail(name_my_boolean, member_ann_builtin_my_boolean, ann_custom_AliasStruct); + CompleteStructMember member_my_boolean = TypeObjectUtils::build_complete_struct_member(common_my_boolean, detail_my_boolean); + TypeObjectUtils::add_complete_struct_member(member_seq_AliasStruct, member_my_boolean); + } CompleteStructType struct_type_AliasStruct = TypeObjectUtils::build_complete_struct_type(struct_flags_AliasStruct, header_AliasStruct, member_seq_AliasStruct); if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER == TypeObjectUtils::build_and_register_struct_type_object(struct_type_AliasStruct, type_name_AliasStruct.to_string(), type_ids_AliasStruct)) diff --git a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp index 17046bf8698..8b82170cc4c 100644 --- a/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp +++ b/test/unittest/dds/xtypes/serializers/idl/types/alias_struct/gen/alias_structTypeObjectSupport.hpp @@ -79,6 +79,34 @@ eProsima_user_DllExport void register_MyRecursiveShort_type_identifier( eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); +/** + * @brief Register MyBoolean related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyBoolean_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + +/** + * @brief Register MyRecursiveBoolean related TypeIdentifier. + * Fully-descriptive TypeIdentifiers are directly registered. + * Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is + * indirectly registered as well. + * + * @param[out] TypeIdentifier of the registered type. + * The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers. + * Invalid TypeIdentifier is returned in case of error. + */ +eProsima_user_DllExport void register_MyRecursiveBoolean_type_identifier( + eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids); + + /** * @brief Register AliasStruct related TypeIdentifier. * Fully-descriptive TypeIdentifiers are directly registered. From 8419c84b95c82c8ede63c06198d1d9628c2d5151 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 09:12:48 +0200 Subject: [PATCH 48/52] Review - Apply JSON suggestions Signed-off-by: tempate --- .../xtypes/serializers/json/CMakeLists.txt | 50 +++++++------------ 1 file changed, 18 insertions(+), 32 deletions(-) diff --git a/test/unittest/dds/xtypes/serializers/json/CMakeLists.txt b/test/unittest/dds/xtypes/serializers/json/CMakeLists.txt index ea0092052f8..7638d5b1d1d 100644 --- a/test/unittest/dds/xtypes/serializers/json/CMakeLists.txt +++ b/test/unittest/dds/xtypes/serializers/json/CMakeLists.txt @@ -12,38 +12,24 @@ # See the License for the specific language governing permissions and # limitations under the License. -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Unfilled_EPROSIMA.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Unfilled_EPROSIMA.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_1.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_1.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_2.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_2.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_3.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_EPROSIMA_3.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Unfilled_OMG.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Unfilled_OMG.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_1.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_1.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_2.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_2.json - COPYONLY) -configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_3.json - ${CMAKE_CURRENT_BINARY_DIR}/types/comprehensive_type/json/ComprehensiveType_Filled_OMG_3.json - COPYONLY) +# Recursively find all .json files in the types directory +file(GLOB_RECURSE JSON_FILES ${CMAKE_CURRENT_SOURCE_DIR}/types/*.json) + +# Iterate over each .json file found +foreach(JSON_FILE ${JSON_FILES}) + # Get the relative path of the .json file + file(RELATIVE_PATH RELATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${JSON_FILE}) + + # Determine the destination directory + set(DEST_DIR ${CMAKE_CURRENT_BINARY_DIR}/${RELATIVE_PATH}) + get_filename_component(DEST_DIR ${DEST_DIR} DIRECTORY) + + # Ensure the destination directory exists + file(MAKE_DIRECTORY ${DEST_DIR}) + + # Copy the .json file to the destination directory + configure_file(${JSON_FILE} ${DEST_DIR} COPYONLY) +endforeach() set(SERIALIZE_JSON_SOURCE DynDataJSONTests.cpp) From 0626d7194a3c357262bf92fd5c75a8d290eabbc4 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 09:21:21 +0200 Subject: [PATCH 49/52] Uncrustify Signed-off-by: tempate --- .../serializers/idl/dynamic_type_idl.cpp | 162 +++++++++--------- .../serializers/idl/DynTypeIDLTests.cpp | 15 +- test/unittest/utils/TreeNodeTests.cpp | 2 +- 3 files changed, 90 insertions(+), 89 deletions(-) diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index d5d89816d84..260d5fecae5 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -53,84 +53,84 @@ ReturnCode_t dyn_type_to_tree( if (kind == TK_STRUCTURE) { - // If is struct, the call is recursive. - // Create new tree node - node = TreeNode(member_name, type->get_name().to_string(), type); + // If is struct, the call is recursive. + // Create new tree node + node = TreeNode(member_name, type->get_name().to_string(), type); - // Get its base class - TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; - ret = type->get_descriptor(type_descriptor); + // Get its base class + TypeDescriptor::_ref_type type_descriptor {traits::make_shared()}; + ret = type->get_descriptor(type_descriptor); + + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); + return ret; + } + + // Add base class as a new branch + const auto base_type = type_descriptor->base_type(); + std::uint32_t first_member = 0; + + if (nullptr != base_type) + { + TreeNode base; + ret = dyn_type_to_tree(base_type, "PARENT", base); if (RETCODE_OK != ret) { - EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting type descriptor of " << node << "."); + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting base type of " << node << "."); return ret; } - // Add base class as a new branch - const auto base_type = type_descriptor->base_type(); - std::uint32_t first_member = 0; - - if (nullptr != base_type) - { - TreeNode base; - ret = dyn_type_to_tree(base_type, "PARENT", base); - - if (RETCODE_OK != ret) - { - EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Error getting base type of " << node << "."); - return ret; - } + base.info.is_base = true; - base.info.is_base = true; + // If the struct is derived from a base, according to the xtypes standard, the first members of the + // struct are the members of the base. + first_member = base_type->get_member_count(); - // If the struct is derived from a base, according to the xtypes standard, the first members of the - // struct are the members of the base. - first_member = base_type->get_member_count(); + node.add_branch(base); + } - node.add_branch(base); - } + // Add each member as a new branch except for the members of its base class + for (std::uint32_t index = first_member; index < type->get_member_count(); index++) + { + traits::ref_type member; + ret = type->get_member_by_index(member, index); - // Add each member as a new branch except for the members of its base class - for (std::uint32_t index = first_member; index < type->get_member_count(); index++) + if (RETCODE_OK != ret) { - traits::ref_type member; - ret = type->get_member_by_index(member, index); - - if (RETCODE_OK != ret) - { - EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting member of " << node << " at index " << index << "."); - return ret; - } + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member of " << node << " at index " << index << "."); + return ret; + } - MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; - ret = member->get_descriptor(member_descriptor); + MemberDescriptor::_ref_type member_descriptor {traits::make_shared()}; + ret = member->get_descriptor(member_descriptor); - if (RETCODE_OK != ret) - { - EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting member descriptor of member " << member->get_name() << - " of " << node << "."); - return ret; - } + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error getting member descriptor of member " << member->get_name() << + " of " << node << "."); + return ret; + } - TreeNode child; - ret = dyn_type_to_tree(member_descriptor->type(), member_descriptor->name().to_string(), child); + TreeNode child; + ret = dyn_type_to_tree(member_descriptor->type(), member_descriptor->name().to_string(), child); - if (RETCODE_OK != ret) - { - EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error building tree of member " << member->get_name() << - " of " << node << "."); - return ret; - } + if (RETCODE_OK != ret) + { + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, + "Error building tree of member " << member->get_name() << + " of " << node << "."); + return ret; + } - child.info.is_key = member_descriptor->is_key(); + child.info.is_key = member_descriptor->is_key(); - // Add each member with its name as a new child in a branch (recursion) - node.add_branch(child); - } + // Add each member with its name as a new child in a branch (recursion) + node.add_branch(child); + } } else { @@ -140,7 +140,7 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << type->get_name().to_string() << "."); + "Error getting IDL representation of " << type->get_name().to_string() << "."); return ret; } @@ -203,7 +203,7 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting member of " << node << " at index " << index << "."); + "Error getting member of " << node << " at index " << index << "."); return ret; } @@ -213,8 +213,8 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting member descriptor of member " << member->get_name() << - " of " << node << "."); + "Error getting member descriptor of member " << member->get_name() << + " of " << node << "."); return ret; } @@ -224,8 +224,8 @@ ReturnCode_t dyn_type_to_tree( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error building tree of member " << member->get_name() << - " of " << node << "."); + "Error building tree of member " << member->get_name() << + " of " << node << "."); return ret; } @@ -384,7 +384,7 @@ ReturnCode_t array_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting element type of " << dyn_type->get_name().to_string() << "."); + "Error getting element type of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -393,7 +393,7 @@ ReturnCode_t array_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << element_type->get_name().to_string() << "."); + "Error getting IDL representation of " << element_type->get_name().to_string() << "."); return ret; } @@ -403,7 +403,7 @@ ReturnCode_t array_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting bounds of " << dyn_type->get_name().to_string() << "."); + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -429,7 +429,7 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -441,7 +441,7 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << key_type->get_name().to_string() << "."); + "Error getting IDL representation of " << key_type->get_name().to_string() << "."); return ret; } @@ -453,7 +453,7 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << value_type->get_name().to_string() << "."); + "Error getting IDL representation of " << value_type->get_name().to_string() << "."); return ret; } @@ -463,7 +463,7 @@ ReturnCode_t map_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting bounds of " << dyn_type->get_name().to_string() << "."); + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -493,7 +493,7 @@ ReturnCode_t sequence_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting element type of " << dyn_type->get_name().to_string() << "."); + "Error getting element type of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -504,7 +504,7 @@ ReturnCode_t sequence_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << element_type->get_name().to_string() << "."); + "Error getting IDL representation of " << element_type->get_name().to_string() << "."); return ret; } @@ -514,7 +514,7 @@ ReturnCode_t sequence_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting bounds of " << dyn_type->get_name().to_string() << "."); + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -553,7 +553,7 @@ ReturnCode_t string_kind_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting bounds of " << dyn_type->get_name().to_string() << "."); + "Error getting bounds of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -779,7 +779,7 @@ ReturnCode_t bitset_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting bounds of " << node.info.dynamic_type->get_name().to_string() << "."); + "Error getting bounds of " << node.info.dynamic_type->get_name().to_string() << "."); return ret; } @@ -950,7 +950,7 @@ ReturnCode_t struct_to_idl( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting IDL representation of " << base_type->get_name().to_string() << "."); + "Error getting IDL representation of " << base_type->get_name().to_string() << "."); return ret; } } @@ -1098,7 +1098,7 @@ ReturnCode_t get_element_type( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); return ret; } @@ -1119,7 +1119,7 @@ ReturnCode_t get_bounds( if (RETCODE_OK != ret) { EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, - "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); + "Error getting type descriptor of " << dyn_type->get_name().to_string() << "."); return ret; } diff --git a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp index 4d103f042ab..e27efe0ce56 100644 --- a/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp +++ b/test/unittest/dds/xtypes/serializers/idl/DynTypeIDLTests.cpp @@ -46,12 +46,12 @@ class DynTypeIDLTests : public ::testing::TestWithParam // Find TypeObjects for the type xtypes::TypeObjectPair type_objs; ASSERT_EQ(DomainParticipantFactory::get_instance()->type_object_registry().get_type_objects( - type_name, type_objs), - fastdds::dds::RETCODE_OK); + type_name, type_objs), + fastdds::dds::RETCODE_OK); // Create DynamicType from TypeObject dyn_type = DynamicTypeBuilderFactory::get_instance()->create_type_w_type_object( - type_objs.complete_type_object)->build(); + type_objs.complete_type_object)->build(); } std::string snake_to_camel( @@ -81,6 +81,7 @@ class DynTypeIDLTests : public ::testing::TestWithParam return camel_case; } + }; /** @@ -119,10 +120,10 @@ TEST_P(DynTypeIDLTests, to_idl) } INSTANTIATE_TEST_SUITE_P( - DynTypeIDLTests, - DynTypeIDLTests, - ::testing::ValuesIn(test::supported_types) -); + DynTypeIDLTests, + DynTypeIDLTests, + ::testing::ValuesIn(test::supported_types) + ); int main( int argc, diff --git a/test/unittest/utils/TreeNodeTests.cpp b/test/unittest/utils/TreeNodeTests.cpp index 28f52b397a0..52330a2bf64 100644 --- a/test/unittest/utils/TreeNodeTests.cpp +++ b/test/unittest/utils/TreeNodeTests.cpp @@ -114,7 +114,7 @@ TEST(TreeNodeTests, one_deep_branch) // Build the tree for (int i = NODE_COUNT - 1; i >= 1; i--) { - trees[i-1].add_branch(trees[i]); + trees[i - 1].add_branch(trees[i]); } const auto& root = trees[0]; From 1e866de3309e495e3eecd6707d196e0934f9fd34 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 09:43:25 +0200 Subject: [PATCH 50/52] Review - Apply suggestions Signed-off-by: tempate --- .../scripts/update_generated_code_from_idl.sh | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/utils/scripts/update_generated_code_from_idl.sh b/utils/scripts/update_generated_code_from_idl.sh index 8592b0edf78..c83ef652f09 100755 --- a/utils/scripts/update_generated_code_from_idl.sh +++ b/utils/scripts/update_generated_code_from_idl.sh @@ -21,6 +21,19 @@ files_needing_output_dir=( './include/fastdds/statistics/monitorservice_types.idl|../../../src/cpp/statistics/types|../../../test/blackbox/types/statistics' './include/fastdds/statistics/types.idl|../../../src/cpp/statistics/types|../../../test/blackbox/types/statistics' './test/blackbox/types/core/core_types.idl|.' + './test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl|./gen' + './test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl|./gen' './test/unittest/dds/xtypes/serializers/json/types/comprehensive_type/ComprehensiveType.idl|./gen' './thirdparty/dds-types-test/IDL/aliases.idl|../../../test/dds-types-test' './thirdparty/dds-types-test/IDL/annotations.idl|../../../test/dds-types-test' @@ -45,19 +58,6 @@ files_needing_output_dir=( './thirdparty/dds-types-test/IDL/strings.idl|../../../test/dds-types-test' './thirdparty/dds-types-test/IDL/structures.idl|../../../test/dds-types-test' './thirdparty/dds-types-test/IDL/unions.idl|../../../test/dds-types-test' - './test/unittest/dds/xtypes/serializers/idl/types/alias_struct/alias_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/array_struct/array_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/bitmask_struct/bitmask_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/bitset_struct/bitset_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/enum_struct/enum_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/extensibility_struct/extensibility_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/key_struct/key_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/map_struct/map_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/primitives_struct/primitives_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/sequence_struct/sequence_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/string_struct/string_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/struct_struct/struct_struct.idl|./gen' - './test/unittest/dds/xtypes/serializers/idl/types/union_struct/union_struct.idl|./gen' ) files_needing_no_typesupport=( From d82da584ad06efa01607abaebff0b2cdd77bc40f Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 10:35:06 +0200 Subject: [PATCH 51/52] Fix - default_type_kind may be used uninitialized Signed-off-by: tempate --- src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp index 260d5fecae5..421abaf6252 100644 --- a/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp +++ b/src/cpp/fastdds/xtypes/serializers/idl/dynamic_type_idl.cpp @@ -1161,6 +1161,9 @@ ReturnCode_t get_default_type_kind( } else { + // Set to none to avoid `may be used uninitialized` error + default_type = TK_NONE; + EPROSIMA_LOG_ERROR(DYNAMIC_TYPE_IDL, "Size " << size << " is not supported."); return RETCODE_BAD_PARAMETER; } From d3842f44b36330302221fee04db16c0bdea9c767 Mon Sep 17 00:00:00 2001 From: tempate Date: Thu, 11 Jul 2024 21:22:17 +0200 Subject: [PATCH 52/52] Fix - signed/unsigned mismatch Signed-off-by: tempate --- test/unittest/utils/TreeNodeTests.cpp | 44 ++++++++++++++++----------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/test/unittest/utils/TreeNodeTests.cpp b/test/unittest/utils/TreeNodeTests.cpp index 52330a2bf64..a1a12cbcebb 100644 --- a/test/unittest/utils/TreeNodeTests.cpp +++ b/test/unittest/utils/TreeNodeTests.cpp @@ -44,13 +44,15 @@ struct TreeNodeTestType */ TEST(TreeNodeTests, one_shallow_branch) { - constexpr auto NODE_COUNT = 2; + constexpr auto DEPTH = 1U; + constexpr auto NODE_COUNT = 2U; + constexpr auto BRANCH_COUNT = 1U; std::vector nodes; std::vector> trees; // Create the nodes and the trees - for (int i = 0; i < NODE_COUNT; i++) + for (unsigned int i = 0; i < NODE_COUNT; i++) { nodes.emplace_back(std::to_string(i)); trees.emplace_back(nodes[i]); @@ -63,7 +65,7 @@ TEST(TreeNodeTests, one_shallow_branch) // Verify the depth const auto tree_depth = root.depth(); - ASSERT_EQ(tree_depth, 1); + ASSERT_EQ(tree_depth, DEPTH); // Verify the nodes are correct const auto tree_nodes = root.all_nodes(); @@ -71,7 +73,7 @@ TEST(TreeNodeTests, one_shallow_branch) // Verify the branch count const auto tree_branches = root.branches(); - ASSERT_EQ(tree_branches.size(), 1); + ASSERT_EQ(tree_branches.size(), BRANCH_COUNT); // Verify that the branch is a leaf ASSERT_TRUE(tree_branches.front().leaf()); @@ -99,13 +101,15 @@ TEST(TreeNodeTests, one_shallow_branch) */ TEST(TreeNodeTests, one_deep_branch) { - constexpr auto NODE_COUNT = 6; + constexpr auto DEPTH = 5U; + constexpr auto NODE_COUNT = 6U; + constexpr auto BRANCH_COUNT = 1U; std::vector nodes; std::vector> trees; // Create the nodes and the trees - for (int i = 0; i < NODE_COUNT; i++) + for (unsigned int i = 0; i < NODE_COUNT; i++) { nodes.emplace_back(std::to_string(i)); trees.emplace_back(nodes[i]); @@ -121,7 +125,7 @@ TEST(TreeNodeTests, one_deep_branch) // Verify the depth const auto tree_depth = root.depth(); - ASSERT_EQ(tree_depth, NODE_COUNT - 1); + ASSERT_EQ(tree_depth, DEPTH); // Verify the nodes are correct const auto tree_nodes = root.all_nodes(); @@ -129,7 +133,7 @@ TEST(TreeNodeTests, one_deep_branch) // Verify the branch count const auto tree_branches = root.branches(); - ASSERT_EQ(tree_branches.size(), 1); + ASSERT_EQ(tree_branches.size(), BRANCH_COUNT); // Verify that the branch is not a leaf ASSERT_FALSE(tree_branches.front().leaf()); @@ -145,13 +149,15 @@ TEST(TreeNodeTests, one_deep_branch) */ TEST(TreeNodeTests, many_shallow_branches) { - constexpr auto NODE_COUNT = 6; + constexpr auto DEPTH = 1U; + constexpr auto NODE_COUNT = 6U; + constexpr auto BRANCH_COUNT = 5U; std::vector nodes; std::vector> trees; // Create the nodes and the trees - for (int i = 0; i < NODE_COUNT; i++) + for (unsigned int i = 0; i < NODE_COUNT; i++) { nodes.emplace_back(std::to_string(i)); trees.emplace_back(nodes[i]); @@ -160,14 +166,14 @@ TEST(TreeNodeTests, many_shallow_branches) // Build the tree auto& root = trees[0]; - for (int i = 1; i < NODE_COUNT; i++) + for (unsigned int i = 1; i < NODE_COUNT; i++) { root.add_branch(nodes[i]); } // Verify the depth const auto tree_depth = root.depth(); - ASSERT_EQ(tree_depth, 1); + ASSERT_EQ(tree_depth, DEPTH); // Verify the node count const auto tree_nodes = root.all_nodes(); @@ -185,7 +191,7 @@ TEST(TreeNodeTests, many_shallow_branches) // Verify the branch count const auto tree_branches = root.branches(); - ASSERT_EQ(tree_branches.size(), NODE_COUNT - 1); + ASSERT_EQ(tree_branches.size(), BRANCH_COUNT); // Verify the branch order i = 0; @@ -216,13 +222,15 @@ TEST(TreeNodeTests, many_shallow_branches) */ TEST(TreeNodeTests, binary_tree) { - constexpr auto NODE_COUNT = 7; + constexpr auto DEPTH = 2U; + constexpr auto NODE_COUNT = 7U; + constexpr auto BRANCH_COUNT = 2U; std::vector nodes; std::vector> trees; // Create the nodes and the trees - for (int i = 0; i < NODE_COUNT; i++) + for (unsigned int i = 0; i < NODE_COUNT; i++) { nodes.emplace_back(std::to_string(i)); trees.emplace_back(nodes[i]); @@ -242,7 +250,7 @@ TEST(TreeNodeTests, binary_tree) // Verify the depth const auto tree_depth = root.depth(); - ASSERT_EQ(tree_depth, 2); + ASSERT_EQ(tree_depth, DEPTH); // Verify the node count const auto tree_nodes = root.all_nodes(); @@ -260,7 +268,7 @@ TEST(TreeNodeTests, binary_tree) // Verify the branch count const auto tree_branches = root.branches(); - ASSERT_EQ(tree_branches.size(), 2); + ASSERT_EQ(tree_branches.size(), BRANCH_COUNT); // Verify the branch order ASSERT_EQ(tree_branches.front().info.name, "1"); @@ -271,7 +279,7 @@ TEST(TreeNodeTests, binary_tree) { // Verify the branch count const auto branch_branches = branch.branches(); - ASSERT_EQ(branch_branches.size(), 2); + ASSERT_EQ(branch_branches.size(), BRANCH_COUNT); // Verify that every branch is a leaf for (const auto& branch_branch : branch_branches)