Program Listing for File TypeObject.h
↰ Return to documentation for file (/tmp/ws/src/fastrtps/include/fastrtps/types/TypeObject.h
)
// Copyright 2018 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.
#ifndef TYPES_TYPE_OBJECT_H
#define TYPES_TYPE_OBJECT_H
#include <fastrtps/types/TypesBase.h>
#include <fastrtps/types/TypeObjectHashId.h>
#include <fastrtps/types/TypeIdentifier.h>
#include <fastrtps/types/AnnotationParameterValue.h>
#include <cstdint>
#include <array>
namespace eprosima {
namespace fastcdr {
class Cdr;
}
}
// The types in this file shall be serialized with XCDR encoding version 2
namespace eprosima {
namespace fastrtps {
namespace types {
/*struct CommonStructMember final {
MemberId member_id;
StructMemberFlag member_flags;
TypeIdentifier member_type_id;
};*/
class CommonStructMember
{
public:
RTPS_DllAPI CommonStructMember();
RTPS_DllAPI ~CommonStructMember();
RTPS_DllAPI CommonStructMember(
const CommonStructMember& x);
RTPS_DllAPI CommonStructMember(
CommonStructMember&& x);
RTPS_DllAPI CommonStructMember& operator=(
const CommonStructMember& x);
RTPS_DllAPI CommonStructMember& operator=(
CommonStructMember&& x);
RTPS_DllAPI inline void member_id(
const MemberId& _member_id) { m_member_id = _member_id; }
RTPS_DllAPI inline void member_id(
MemberId&& _member_id) { m_member_id = std::move(_member_id); }
RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
RTPS_DllAPI inline void member_flags(
const StructMemberFlag& _member_flags) { m_member_flags = _member_flags; }
RTPS_DllAPI inline void member_flags(
StructMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
RTPS_DllAPI inline const StructMemberFlag& member_flags() const { return m_member_flags; }
RTPS_DllAPI inline StructMemberFlag& member_flags() { return m_member_flags; }
RTPS_DllAPI inline void member_type_id(
const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
RTPS_DllAPI inline void member_type_id(
TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonStructMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonStructMember& other) const;
RTPS_DllAPI bool consistent(
const CommonStructMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
MemberId m_member_id;
StructMemberFlag m_member_flags;
TypeIdentifier m_member_type_id;
};
// COMPLETE Details for a member of an aggregate type
/*struct CompleteMemberDetail final{
MemberName name;
AppliedBuiltinMemberAnnotations ann_builtin; // Optional
AppliedAnnotationSeq ann_custom; // Optional
};*/
class CompleteMemberDetail
{
public:
RTPS_DllAPI CompleteMemberDetail();
RTPS_DllAPI ~CompleteMemberDetail();
RTPS_DllAPI CompleteMemberDetail(
const CompleteMemberDetail& x);
RTPS_DllAPI CompleteMemberDetail(
CompleteMemberDetail&& x);
RTPS_DllAPI CompleteMemberDetail& operator=(
const CompleteMemberDetail& x);
RTPS_DllAPI CompleteMemberDetail& operator=(
CompleteMemberDetail&& x);
RTPS_DllAPI inline void name(
const MemberName& _name) { m_name = _name; }
RTPS_DllAPI inline void name(
MemberName&& _name) { m_name = std::move(_name); }
RTPS_DllAPI inline const MemberName& name() const { return m_name; }
RTPS_DllAPI inline MemberName& name() { return m_name; }
RTPS_DllAPI inline void ann_builtin(
const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
RTPS_DllAPI inline void ann_builtin(
AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
RTPS_DllAPI inline void ann_custom(
const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
RTPS_DllAPI inline void ann_custom(
AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteMemberDetail& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteMemberDetail& other) const;
RTPS_DllAPI bool consistent(
const CompleteMemberDetail& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
MemberName m_name;
AppliedBuiltinMemberAnnotations m_ann_builtin;
AppliedAnnotationSeq m_ann_custom;
};
// MINIMAL Details for a member of an aggregate type
/*struct MinimalMemberDetail final{
NameHash name_hash;
};*/
class MinimalMemberDetail final
{
public:
RTPS_DllAPI MinimalMemberDetail();
RTPS_DllAPI ~MinimalMemberDetail();
RTPS_DllAPI MinimalMemberDetail(
const MinimalMemberDetail& x);
RTPS_DllAPI MinimalMemberDetail(
MinimalMemberDetail&& x);
RTPS_DllAPI MinimalMemberDetail& operator=(
const MinimalMemberDetail& x);
RTPS_DllAPI MinimalMemberDetail& operator=(
MinimalMemberDetail&& x);
RTPS_DllAPI inline void name_hash(
const NameHash& _name_hash) { m_name_hash = _name_hash; }
RTPS_DllAPI inline void name_hash(
NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalMemberDetail& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalMemberDetail& other) const;
RTPS_DllAPI bool consistent(
const MinimalMemberDetail& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
NameHash m_name_hash;
};
// Member of an aggregate type
/*struct CompleteStructMember {
CommonStructMember common;
CompleteMemberDetail detail;
};*/
class CompleteStructMember
{
public:
RTPS_DllAPI CompleteStructMember();
RTPS_DllAPI ~CompleteStructMember();
RTPS_DllAPI CompleteStructMember(
const CompleteStructMember& x);
RTPS_DllAPI CompleteStructMember(
CompleteStructMember&& x);
RTPS_DllAPI CompleteStructMember& operator=(
const CompleteStructMember& x);
RTPS_DllAPI CompleteStructMember& operator=(
CompleteStructMember&& x);
RTPS_DllAPI inline void common(
const CommonStructMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonStructMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteStructMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteStructMember& other) const;
RTPS_DllAPI bool consistent(
const CompleteStructMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonStructMember m_common;
CompleteMemberDetail m_detail;
};
// Ordered by the member_index
typedef std::vector<CompleteStructMember> CompleteStructMemberSeq;
// Member of an aggregate type
/*struct MinimalStructMember {
CommonStructMember common;
MinimalMemberDetail detail;
};*/
class MinimalStructMember
{
public:
RTPS_DllAPI MinimalStructMember();
RTPS_DllAPI ~MinimalStructMember();
RTPS_DllAPI MinimalStructMember(
const MinimalStructMember& x);
RTPS_DllAPI MinimalStructMember(
MinimalStructMember&& x);
RTPS_DllAPI MinimalStructMember& operator=(
const MinimalStructMember& x);
RTPS_DllAPI MinimalStructMember& operator=(
MinimalStructMember&& x);
RTPS_DllAPI inline void common(
const CommonStructMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonStructMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonStructMember& common() const { return m_common; }
RTPS_DllAPI inline CommonStructMember& common() { return m_common; }
RTPS_DllAPI inline void detail(
const MinimalMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalStructMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalStructMember& other) const;
RTPS_DllAPI bool consistent(
const MinimalStructMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonStructMember m_common;
MinimalMemberDetail m_detail;
};
// Ordered by common.member_id
typedef std::vector<MinimalStructMember> MinimalStructMemberSeq;
/*struct AppliedBuiltinTypeAnnotations {
AppliedVerbatimAnnotation verbatim; // verbatim(...) // optional
};*/
class AppliedBuiltinTypeAnnotations
{
public:
RTPS_DllAPI AppliedBuiltinTypeAnnotations();
RTPS_DllAPI ~AppliedBuiltinTypeAnnotations();
RTPS_DllAPI AppliedBuiltinTypeAnnotations(
const AppliedBuiltinTypeAnnotations& x);
RTPS_DllAPI AppliedBuiltinTypeAnnotations(
AppliedBuiltinTypeAnnotations&& x);
RTPS_DllAPI AppliedBuiltinTypeAnnotations& operator=(
const AppliedBuiltinTypeAnnotations& x);
RTPS_DllAPI AppliedBuiltinTypeAnnotations& operator=(
AppliedBuiltinTypeAnnotations&& x);
RTPS_DllAPI inline void verbatim(
const AppliedVerbatimAnnotation& _verbatim) { m_verbatim = _verbatim; }
RTPS_DllAPI inline void verbatim(
AppliedVerbatimAnnotation&& _verbatim) { m_verbatim = std::move(_verbatim); }
RTPS_DllAPI inline const AppliedVerbatimAnnotation& verbatim() const { return m_verbatim; }
RTPS_DllAPI inline AppliedVerbatimAnnotation& verbatim() { return m_verbatim; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const AppliedBuiltinTypeAnnotations& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const AppliedBuiltinTypeAnnotations& other) const;
RTPS_DllAPI bool consistent(
const AppliedBuiltinTypeAnnotations& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AppliedVerbatimAnnotation m_verbatim;
};
/*struct MinimalTypeDetail final{
// Empty. Available for future extension
};*/
class MinimalTypeDetail
{
public:
RTPS_DllAPI MinimalTypeDetail();
RTPS_DllAPI ~MinimalTypeDetail();
RTPS_DllAPI MinimalTypeDetail(
const MinimalTypeDetail& x);
RTPS_DllAPI MinimalTypeDetail(
MinimalTypeDetail&& x);
RTPS_DllAPI MinimalTypeDetail& operator=(
const MinimalTypeDetail& x);
RTPS_DllAPI MinimalTypeDetail& operator=(
MinimalTypeDetail&& x);
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalTypeDetail& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalTypeDetail&) const { return true; }
RTPS_DllAPI bool consistent(
const MinimalTypeDetail& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
};
/*struct CompleteTypeDetail final{
AppliedBuiltinTypeAnnotations ann_builtin; // optional
AppliedAnnotationSeq ann_custom; // optional
QualifiedTypeName type_name;
};*/
class CompleteTypeDetail
{
public:
RTPS_DllAPI CompleteTypeDetail();
RTPS_DllAPI ~CompleteTypeDetail();
RTPS_DllAPI CompleteTypeDetail(
const CompleteTypeDetail& x);
RTPS_DllAPI CompleteTypeDetail(
CompleteTypeDetail&& x);
RTPS_DllAPI CompleteTypeDetail& operator=(
const CompleteTypeDetail& x);
RTPS_DllAPI CompleteTypeDetail& operator=(
CompleteTypeDetail&& x);
RTPS_DllAPI inline void ann_builtin(
const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
RTPS_DllAPI inline void ann_builtin(
AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
RTPS_DllAPI inline void ann_custom(
const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
RTPS_DllAPI inline void ann_custom(
AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
RTPS_DllAPI inline void type_name(
const QualifiedTypeName& _type_name) { m_type_name = _type_name; }
RTPS_DllAPI inline void type_name(
QualifiedTypeName&& _type_name) { m_type_name = std::move(_type_name); }
RTPS_DllAPI inline const QualifiedTypeName& type_name() const { return m_type_name; }
RTPS_DllAPI inline QualifiedTypeName& type_name() { return m_type_name; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteTypeDetail& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteTypeDetail& other) const;
RTPS_DllAPI bool consistent(
const CompleteTypeDetail& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AppliedBuiltinTypeAnnotations m_ann_builtin;
AppliedAnnotationSeq m_ann_custom;
QualifiedTypeName m_type_name;
};
/*struct CompleteStructHeader {
TypeIdentifier base_type;
CompleteTypeDetail detail;
};*/
class CompleteStructHeader
{
public:
RTPS_DllAPI CompleteStructHeader();
RTPS_DllAPI ~CompleteStructHeader();
RTPS_DllAPI CompleteStructHeader(
const CompleteStructHeader& x);
RTPS_DllAPI CompleteStructHeader(
CompleteStructHeader&& x);
RTPS_DllAPI CompleteStructHeader& operator=(
const CompleteStructHeader& x);
RTPS_DllAPI CompleteStructHeader& operator=(
CompleteStructHeader&& x);
RTPS_DllAPI inline void base_type(
const TypeIdentifier& _base_type) { m_base_type = _base_type; }
RTPS_DllAPI inline void base_type(
TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteStructHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteStructHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteStructHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
TypeIdentifier m_base_type;
CompleteTypeDetail m_detail;
};
/*struct MinimalStructHeader {
TypeIdentifier base_type;
MinimalTypeDetail detail;
};*/
class MinimalStructHeader
{
public:
RTPS_DllAPI MinimalStructHeader();
RTPS_DllAPI ~MinimalStructHeader();
RTPS_DllAPI MinimalStructHeader(
const MinimalStructHeader& x);
RTPS_DllAPI MinimalStructHeader(
MinimalStructHeader&& x);
RTPS_DllAPI MinimalStructHeader& operator=(
const MinimalStructHeader& x);
RTPS_DllAPI MinimalStructHeader& operator=(
MinimalStructHeader&& x);
RTPS_DllAPI inline void base_type(
const TypeIdentifier& _base_type) { m_base_type = _base_type; }
RTPS_DllAPI inline void base_type(
TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
RTPS_DllAPI inline void detail(
const MinimalTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalStructHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalStructHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalStructHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
TypeIdentifier m_base_type;
MinimalTypeDetail m_detail;
};
/*struct CompleteStructType final{
StructTypeFlag struct_flags;
CompleteStructHeader header;
CompleteStructMemberSeq member_seq;
};*/
class CompleteStructType
{
public:
RTPS_DllAPI CompleteStructType();
RTPS_DllAPI ~CompleteStructType();
RTPS_DllAPI CompleteStructType(
const CompleteStructType& x);
RTPS_DllAPI CompleteStructType(
CompleteStructType&& x);
RTPS_DllAPI CompleteStructType& operator=(
const CompleteStructType& x);
RTPS_DllAPI CompleteStructType& operator=(
CompleteStructType&& x);
RTPS_DllAPI inline void struct_flags(
const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
RTPS_DllAPI inline void struct_flags(
StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
RTPS_DllAPI inline void header(
const CompleteStructHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteStructHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteStructHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteStructHeader& header() { return m_header; }
RTPS_DllAPI inline void member_seq(
const CompleteStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
CompleteStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const CompleteStructMemberSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline CompleteStructMemberSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteStructType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteStructType& other) const;
RTPS_DllAPI bool consistent(
const CompleteStructType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
StructTypeFlag m_struct_flags;
CompleteStructHeader m_header;
CompleteStructMemberSeq m_member_seq;
};
/*struct MinimalStructType final{
StructTypeFlag struct_flags;
MinimalStructHeader header;
MinimalStructMemberSeq member_seq;
};*/
class MinimalStructType
{
public:
RTPS_DllAPI MinimalStructType();
RTPS_DllAPI ~MinimalStructType();
RTPS_DllAPI MinimalStructType(
const MinimalStructType& x);
RTPS_DllAPI MinimalStructType(
MinimalStructType&& x);
RTPS_DllAPI MinimalStructType& operator=(
const MinimalStructType& x);
RTPS_DllAPI MinimalStructType& operator=(
MinimalStructType&& x);
RTPS_DllAPI inline void struct_flags(
const StructTypeFlag& _struct_flags) { m_struct_flags = _struct_flags; }
RTPS_DllAPI inline void struct_flags(
StructTypeFlag&& _struct_flags) { m_struct_flags = std::move(_struct_flags); }
RTPS_DllAPI inline const StructTypeFlag& struct_flags() const { return m_struct_flags; }
RTPS_DllAPI inline StructTypeFlag& struct_flags() { return m_struct_flags; }
RTPS_DllAPI inline void header(
const MinimalStructHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalStructHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalStructHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalStructHeader& header() { return m_header; }
RTPS_DllAPI inline void member_seq(
const MinimalStructMemberSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
MinimalStructMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const MinimalStructMemberSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline MinimalStructMemberSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalStructType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalStructType& other) const;
RTPS_DllAPI bool consistent(
const MinimalStructType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
StructTypeFlag m_struct_flags;
MinimalStructHeader m_header;
MinimalStructMemberSeq m_member_seq;
};
// --- Union: ---------------------------------------------------------
// Case labels that apply to a member of a union type
// Ordered by their values
typedef std::vector<int32_t> UnionCaseLabelSeq;
/*struct CommonUnionMember final{
MemberId member_id;
UnionMemberFlag member_flags;
TypeIdentifier type_id;
UnionCaseLabelSeq label_seq;
};*/
class CommonUnionMember
{
public:
RTPS_DllAPI CommonUnionMember();
RTPS_DllAPI ~CommonUnionMember();
RTPS_DllAPI CommonUnionMember(
const CommonUnionMember& x);
RTPS_DllAPI CommonUnionMember(
CommonUnionMember&& x);
RTPS_DllAPI CommonUnionMember& operator=(
const CommonUnionMember& x);
RTPS_DllAPI CommonUnionMember& operator=(
CommonUnionMember&& x);
RTPS_DllAPI inline void member_id(
const MemberId& _member_id) { m_member_id = _member_id; }
RTPS_DllAPI inline void member_id(
MemberId&& _member_id) { m_member_id = std::move(_member_id); }
RTPS_DllAPI inline const MemberId& member_id() const { return m_member_id; }
RTPS_DllAPI inline MemberId& member_id() { return m_member_id; }
RTPS_DllAPI inline void member_flags(
const UnionMemberFlag& _member_flags) { m_member_flags = _member_flags; }
RTPS_DllAPI inline void member_flags(
UnionMemberFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
RTPS_DllAPI inline const UnionMemberFlag& member_flags() const { return m_member_flags; }
RTPS_DllAPI inline UnionMemberFlag& member_flags() { return m_member_flags; }
RTPS_DllAPI inline void type_id(
const TypeIdentifier& _type_id) { m_type_id = _type_id; }
RTPS_DllAPI inline void type_id(
TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
RTPS_DllAPI inline void label_seq(
const UnionCaseLabelSeq& _label_seq) { m_label_seq = _label_seq; }
RTPS_DllAPI inline void label_seq(
UnionCaseLabelSeq&& _label_seq) { m_label_seq = std::move(_label_seq); }
RTPS_DllAPI inline const UnionCaseLabelSeq& label_seq() const { return m_label_seq; }
RTPS_DllAPI inline UnionCaseLabelSeq& label_seq() { return m_label_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonUnionMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonUnionMember& other) const;
RTPS_DllAPI bool consistent(
const CommonUnionMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
MemberId m_member_id;
UnionMemberFlag m_member_flags;
TypeIdentifier m_type_id;
UnionCaseLabelSeq m_label_seq;
};
// Member of a union type
/*struct CompleteUnionMember {
CommonUnionMember common;
CompleteMemberDetail detail;
};*/
class CompleteUnionMember
{
public:
RTPS_DllAPI CompleteUnionMember();
RTPS_DllAPI ~CompleteUnionMember();
RTPS_DllAPI CompleteUnionMember(
const CompleteUnionMember& x);
RTPS_DllAPI CompleteUnionMember(
CompleteUnionMember&& x);
RTPS_DllAPI CompleteUnionMember& operator=(
const CompleteUnionMember& x);
RTPS_DllAPI CompleteUnionMember& operator=(
CompleteUnionMember&& x);
RTPS_DllAPI inline void common(
const CommonUnionMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonUnionMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteUnionMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteUnionMember& other) const;
RTPS_DllAPI bool consistent(
const CompleteUnionMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonUnionMember m_common;
CompleteMemberDetail m_detail;
};
// Ordered by member_index
typedef std::vector<CompleteUnionMember> CompleteUnionMemberSeq;
// Member of a union type
/*struct MinimalUnionMember {
CommonUnionMember common;
MinimalMemberDetail detail;
};*/
class MinimalUnionMember
{
public:
RTPS_DllAPI MinimalUnionMember();
RTPS_DllAPI ~MinimalUnionMember();
RTPS_DllAPI MinimalUnionMember(
const MinimalUnionMember& x);
RTPS_DllAPI MinimalUnionMember(
MinimalUnionMember&& x);
RTPS_DllAPI MinimalUnionMember& operator=(
const MinimalUnionMember& x);
RTPS_DllAPI MinimalUnionMember& operator=(
MinimalUnionMember&& x);
RTPS_DllAPI inline void common(
const CommonUnionMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonUnionMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonUnionMember& common() const { return m_common; }
RTPS_DllAPI inline CommonUnionMember& common() { return m_common; }
RTPS_DllAPI inline void detail(
const MinimalMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalUnionMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalUnionMember& other) const;
RTPS_DllAPI bool consistent(
const MinimalUnionMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonUnionMember m_common;
MinimalMemberDetail m_detail;
};
// Ordered by MinimalUnionMember.common.member_id
typedef std::vector<MinimalUnionMember> MinimalUnionMemberSeq;
/*struct CommonDiscriminatorMember final{
UnionDiscriminatorFlag member_flags;
TypeIdentifier type_id;
};*/
class CommonDiscriminatorMember
{
public:
RTPS_DllAPI CommonDiscriminatorMember();
RTPS_DllAPI ~CommonDiscriminatorMember();
RTPS_DllAPI CommonDiscriminatorMember(
const CommonDiscriminatorMember& x);
RTPS_DllAPI CommonDiscriminatorMember(
CommonDiscriminatorMember&& x);
RTPS_DllAPI CommonDiscriminatorMember& operator=(
const CommonDiscriminatorMember& x);
RTPS_DllAPI CommonDiscriminatorMember& operator=(
CommonDiscriminatorMember&& x);
RTPS_DllAPI inline void member_flags(
const UnionDiscriminatorFlag& _member_flags) { m_member_flags = _member_flags; }
RTPS_DllAPI inline void member_flags(
UnionDiscriminatorFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
RTPS_DllAPI inline const UnionDiscriminatorFlag& member_flags() const { return m_member_flags; }
RTPS_DllAPI inline UnionDiscriminatorFlag& member_flags() { return m_member_flags; }
RTPS_DllAPI inline void type_id(
const TypeIdentifier& _type_id) { m_type_id = _type_id; }
RTPS_DllAPI inline void type_id(
TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonDiscriminatorMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonDiscriminatorMember& other) const;
RTPS_DllAPI bool consistent(
const CommonDiscriminatorMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
UnionDiscriminatorFlag m_member_flags;
TypeIdentifier m_type_id;
};
// Member of a union type
/*struct CompleteDiscriminatorMember {
CommonDiscriminatorMember common;
AppliedBuiltinTypeAnnotations ann_builtin; // Optional
AppliedAnnotationSeq ann_custom; // Optional
};*/
class CompleteDiscriminatorMember
{
public:
RTPS_DllAPI CompleteDiscriminatorMember();
RTPS_DllAPI ~CompleteDiscriminatorMember();
RTPS_DllAPI CompleteDiscriminatorMember(
const CompleteDiscriminatorMember& x);
RTPS_DllAPI CompleteDiscriminatorMember(
CompleteDiscriminatorMember&& x);
RTPS_DllAPI CompleteDiscriminatorMember& operator=(
const CompleteDiscriminatorMember& x);
RTPS_DllAPI CompleteDiscriminatorMember& operator=(
CompleteDiscriminatorMember&& x);
RTPS_DllAPI inline void common(
const CommonDiscriminatorMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
RTPS_DllAPI inline void ann_builtin(
const AppliedBuiltinTypeAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
RTPS_DllAPI inline void ann_builtin(
AppliedBuiltinTypeAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
RTPS_DllAPI inline const AppliedBuiltinTypeAnnotations& ann_builtin() const { return m_ann_builtin; }
RTPS_DllAPI inline AppliedBuiltinTypeAnnotations& ann_builtin() { return m_ann_builtin; }
RTPS_DllAPI inline void ann_custom(
const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
RTPS_DllAPI inline void ann_custom(
AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteDiscriminatorMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteDiscriminatorMember& other) const;
RTPS_DllAPI bool consistent(
const CompleteDiscriminatorMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonDiscriminatorMember m_common;
AppliedBuiltinTypeAnnotations m_ann_builtin;
AppliedAnnotationSeq m_ann_custom;
};
// Member of a union type
/*struct MinimalDiscriminatorMember {
CommonDiscriminatorMember common;
};*/
class MinimalDiscriminatorMember
{
public:
RTPS_DllAPI MinimalDiscriminatorMember();
RTPS_DllAPI ~MinimalDiscriminatorMember();
RTPS_DllAPI MinimalDiscriminatorMember(
const MinimalDiscriminatorMember& x);
RTPS_DllAPI MinimalDiscriminatorMember(
MinimalDiscriminatorMember&& x);
RTPS_DllAPI MinimalDiscriminatorMember& operator=(
const MinimalDiscriminatorMember& x);
RTPS_DllAPI MinimalDiscriminatorMember& operator=(
MinimalDiscriminatorMember&& x);
RTPS_DllAPI inline void common(
const CommonDiscriminatorMember& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonDiscriminatorMember&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonDiscriminatorMember& common() const { return m_common; }
RTPS_DllAPI inline CommonDiscriminatorMember& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalDiscriminatorMember& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalDiscriminatorMember& other) const;
RTPS_DllAPI bool consistent(
const MinimalDiscriminatorMember& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonDiscriminatorMember m_common;
};
/*struct CompleteUnionHeader {
CompleteTypeDetail detail;
};*/
class CompleteUnionHeader
{
public:
RTPS_DllAPI CompleteUnionHeader();
RTPS_DllAPI ~CompleteUnionHeader();
RTPS_DllAPI CompleteUnionHeader(
const CompleteUnionHeader& x);
RTPS_DllAPI CompleteUnionHeader(
CompleteUnionHeader&& x);
RTPS_DllAPI CompleteUnionHeader& operator=(
const CompleteUnionHeader& x);
RTPS_DllAPI CompleteUnionHeader& operator=(
CompleteUnionHeader&& x);
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteUnionHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteUnionHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteUnionHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CompleteTypeDetail m_detail;
};
/*struct MinimalUnionHeader {
MinimalTypeDetail detail;
};*/
class MinimalUnionHeader
{
public:
RTPS_DllAPI MinimalUnionHeader();
RTPS_DllAPI ~MinimalUnionHeader();
RTPS_DllAPI MinimalUnionHeader(
const MinimalUnionHeader& x);
RTPS_DllAPI MinimalUnionHeader(
MinimalUnionHeader&& x);
RTPS_DllAPI MinimalUnionHeader& operator=(
const MinimalUnionHeader& x);
RTPS_DllAPI MinimalUnionHeader& operator=(
MinimalUnionHeader&& x);
RTPS_DllAPI inline void detail(
const MinimalTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalUnionHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalUnionHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalUnionHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
MinimalTypeDetail m_detail;
};
/*struct CompleteUnionType final{
UnionTypeFlag union_flags;
CompleteUnionHeader header;
CompleteDiscriminatorMember discriminator;
CompleteUnionMemberSeq member_seq;
};*/
class CompleteUnionType
{
public:
RTPS_DllAPI CompleteUnionType();
RTPS_DllAPI ~CompleteUnionType();
RTPS_DllAPI CompleteUnionType(
const CompleteUnionType& x);
RTPS_DllAPI CompleteUnionType(
CompleteUnionType&& x);
RTPS_DllAPI CompleteUnionType& operator=(
const CompleteUnionType& x);
RTPS_DllAPI CompleteUnionType& operator=(
CompleteUnionType&& x);
RTPS_DllAPI inline void union_flags(
const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
RTPS_DllAPI inline void union_flags(
UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
RTPS_DllAPI inline void header(
const CompleteUnionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteUnionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteUnionHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteUnionHeader& header() { return m_header; }
RTPS_DllAPI inline void discriminator(
const CompleteDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
RTPS_DllAPI inline void discriminator(
CompleteDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
RTPS_DllAPI inline const CompleteDiscriminatorMember& discriminator() const { return m_discriminator; }
RTPS_DllAPI inline CompleteDiscriminatorMember& discriminator() { return m_discriminator; }
RTPS_DllAPI inline void member_seq(
const CompleteUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
CompleteUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const CompleteUnionMemberSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline CompleteUnionMemberSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteUnionType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteUnionType& other) const;
RTPS_DllAPI bool consistent(
const CompleteUnionType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
UnionTypeFlag m_union_flags;
CompleteUnionHeader m_header;
CompleteDiscriminatorMember m_discriminator;
CompleteUnionMemberSeq m_member_seq;
};
/*struct MinimalUnionType final{
UnionTypeFlag union_flags;
MinimalUnionHeader header;
MinimalDiscriminatorMember discriminator;
MinimalUnionMemberSeq member_seq;
};*/
class MinimalUnionType
{
public:
RTPS_DllAPI MinimalUnionType();
RTPS_DllAPI ~MinimalUnionType();
RTPS_DllAPI MinimalUnionType(
const MinimalUnionType& x);
RTPS_DllAPI MinimalUnionType(
MinimalUnionType&& x);
RTPS_DllAPI MinimalUnionType& operator=(
const MinimalUnionType& x);
RTPS_DllAPI MinimalUnionType& operator=(
MinimalUnionType&& x);
RTPS_DllAPI inline void union_flags(
const UnionTypeFlag& _union_flags) { m_union_flags = _union_flags; }
RTPS_DllAPI inline void union_flags(
UnionTypeFlag&& _union_flags) { m_union_flags = std::move(_union_flags); }
RTPS_DllAPI inline const UnionTypeFlag& union_flags() const { return m_union_flags; }
RTPS_DllAPI inline UnionTypeFlag& union_flags() { return m_union_flags; }
RTPS_DllAPI inline void header(
const MinimalUnionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalUnionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalUnionHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalUnionHeader& header() { return m_header; }
RTPS_DllAPI inline void discriminator(
const MinimalDiscriminatorMember& _discriminator) { m_discriminator = _discriminator; }
RTPS_DllAPI inline void discriminator(
MinimalDiscriminatorMember&& _discriminator) { m_discriminator = std::move(_discriminator); }
RTPS_DllAPI inline const MinimalDiscriminatorMember& discriminator() const { return m_discriminator; }
RTPS_DllAPI inline MinimalDiscriminatorMember& discriminator() { return m_discriminator; }
RTPS_DllAPI inline void member_seq(
const MinimalUnionMemberSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
MinimalUnionMemberSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const MinimalUnionMemberSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline MinimalUnionMemberSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalUnionType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalUnionType& other) const;
RTPS_DllAPI bool consistent(
const MinimalUnionType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
UnionTypeFlag m_union_flags;
MinimalUnionHeader m_header;
MinimalDiscriminatorMember m_discriminator;
MinimalUnionMemberSeq m_member_seq;
};
// --- Annotation: ---------------------------------------------------
/*struct CommonAnnotationParameter final{
AnnotationParameterFlag member_flags;
TypeIdentifier member_type_id;
};*/
class CommonAnnotationParameter
{
public:
RTPS_DllAPI CommonAnnotationParameter();
RTPS_DllAPI ~CommonAnnotationParameter();
RTPS_DllAPI CommonAnnotationParameter(
const CommonAnnotationParameter& x);
RTPS_DllAPI CommonAnnotationParameter(
CommonAnnotationParameter&& x);
RTPS_DllAPI CommonAnnotationParameter& operator=(
const CommonAnnotationParameter& x);
RTPS_DllAPI CommonAnnotationParameter& operator=(
CommonAnnotationParameter&& x);
RTPS_DllAPI inline void member_flags(
const AnnotationParameterFlag& _member_flags) { m_member_flags = _member_flags; }
RTPS_DllAPI inline void member_flags(
AnnotationParameterFlag&& _member_flags) { m_member_flags = std::move(_member_flags); }
RTPS_DllAPI inline const AnnotationParameterFlag& member_flags() const { return m_member_flags; }
RTPS_DllAPI inline AnnotationParameterFlag& member_flags() { return m_member_flags; }
RTPS_DllAPI inline void member_type_id(
const TypeIdentifier& _member_type_id) { m_member_type_id = _member_type_id; }
RTPS_DllAPI inline void member_type_id(
TypeIdentifier&& _member_type_id) { m_member_type_id = std::move(_member_type_id); }
RTPS_DllAPI inline const TypeIdentifier& member_type_id() const { return m_member_type_id; }
RTPS_DllAPI inline TypeIdentifier& member_type_id() { return m_member_type_id; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonAnnotationParameter& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonAnnotationParameter& other) const;
RTPS_DllAPI bool consistent(
const CommonAnnotationParameter& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AnnotationParameterFlag m_member_flags;
TypeIdentifier m_member_type_id;
};
// Member of an annotation type
/*struct CompleteAnnotationParameter {
CommonAnnotationParameter common;
MemberName name;
AnnotationParameterValue default_value;
};*/
class CompleteAnnotationParameter
{
public:
RTPS_DllAPI CompleteAnnotationParameter();
RTPS_DllAPI ~CompleteAnnotationParameter();
RTPS_DllAPI CompleteAnnotationParameter(
const CompleteAnnotationParameter& x);
RTPS_DllAPI CompleteAnnotationParameter(
CompleteAnnotationParameter&& x);
RTPS_DllAPI CompleteAnnotationParameter& operator=(
const CompleteAnnotationParameter& x);
RTPS_DllAPI CompleteAnnotationParameter& operator=(
CompleteAnnotationParameter&& x);
RTPS_DllAPI inline void common(
const CommonAnnotationParameter& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
RTPS_DllAPI inline void name(
const MemberName& _name) { m_name = _name; }
RTPS_DllAPI inline void name(
MemberName&& _name) { m_name = std::move(_name); }
RTPS_DllAPI inline const MemberName& name() const { return m_name; }
RTPS_DllAPI inline MemberName& name() { return m_name; }
RTPS_DllAPI inline void default_value(
const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
RTPS_DllAPI inline void default_value(
AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAnnotationParameter& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAnnotationParameter& other) const;
RTPS_DllAPI bool consistent(
const CompleteAnnotationParameter& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonAnnotationParameter m_common;
MemberName m_name;
AnnotationParameterValue m_default_value;
};
// Ordered by CompleteAnnotationParameter.name
typedef std::vector<CompleteAnnotationParameter> CompleteAnnotationParameterSeq;
/*struct MinimalAnnotationParameter {
CommonAnnotationParameter common;
NameHash name_hash;
AnnotationParameterValue default_value;
};*/
class MinimalAnnotationParameter
{
public:
RTPS_DllAPI MinimalAnnotationParameter();
RTPS_DllAPI ~MinimalAnnotationParameter();
RTPS_DllAPI MinimalAnnotationParameter(
const MinimalAnnotationParameter& x);
RTPS_DllAPI MinimalAnnotationParameter(
MinimalAnnotationParameter&& x);
RTPS_DllAPI MinimalAnnotationParameter& operator=(
const MinimalAnnotationParameter& x);
RTPS_DllAPI MinimalAnnotationParameter& operator=(
MinimalAnnotationParameter&& x);
RTPS_DllAPI inline void common(
const CommonAnnotationParameter& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonAnnotationParameter&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonAnnotationParameter& common() const { return m_common; }
RTPS_DllAPI inline CommonAnnotationParameter& common() { return m_common; }
RTPS_DllAPI inline void name(
const MemberName& _name) { m_name = _name; }
RTPS_DllAPI inline void name(
MemberName&& _name) { m_name = std::move(_name); }
RTPS_DllAPI inline const MemberName& name() const { return m_name; }
RTPS_DllAPI inline MemberName& name() { return m_name; }
RTPS_DllAPI inline void default_value(
const AnnotationParameterValue& _default_value) { m_default_value = _default_value; }
RTPS_DllAPI inline void default_value(
AnnotationParameterValue&& _default_value) { m_default_value = std::move(_default_value); }
RTPS_DllAPI inline const AnnotationParameterValue& default_value() const { return m_default_value; }
RTPS_DllAPI inline AnnotationParameterValue& default_value() { return m_default_value; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAnnotationParameter& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAnnotationParameter& other) const;
RTPS_DllAPI bool consistent(
const MinimalAnnotationParameter& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonAnnotationParameter m_common;
MemberName m_name;
AnnotationParameterValue m_default_value;
};
// Ordered by MinimalAnnotationParameter.name_hash
typedef std::vector<MinimalAnnotationParameter> MinimalAnnotationParameterSeq;
/*struct CompleteAnnotationHeader {
QualifiedTypeName annotation_name;
};*/
class CompleteAnnotationHeader
{
public:
RTPS_DllAPI CompleteAnnotationHeader();
RTPS_DllAPI ~CompleteAnnotationHeader();
RTPS_DllAPI CompleteAnnotationHeader(
const CompleteAnnotationHeader& x);
RTPS_DllAPI CompleteAnnotationHeader(
CompleteAnnotationHeader&& x);
RTPS_DllAPI CompleteAnnotationHeader& operator=(
const CompleteAnnotationHeader& x);
RTPS_DllAPI CompleteAnnotationHeader& operator=(
CompleteAnnotationHeader&& x);
RTPS_DllAPI inline void annotation_name(
const QualifiedTypeName& _annotation_name) { m_annotation_name = _annotation_name; }
RTPS_DllAPI inline void annotation_name(
QualifiedTypeName&& _annotation_name) { m_annotation_name = std::move(_annotation_name); }
RTPS_DllAPI inline const QualifiedTypeName& annotation_name() const { return m_annotation_name; }
RTPS_DllAPI inline QualifiedTypeName& annotation_name() { return m_annotation_name; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAnnotationHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAnnotationHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteAnnotationHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
QualifiedTypeName m_annotation_name;
};
/*struct MinimalAnnotationHeader {
// Empty. Available for future extension
};*/
class MinimalAnnotationHeader
{
public:
RTPS_DllAPI MinimalAnnotationHeader();
RTPS_DllAPI ~MinimalAnnotationHeader();
RTPS_DllAPI MinimalAnnotationHeader(
const MinimalAnnotationHeader& x);
RTPS_DllAPI MinimalAnnotationHeader(
MinimalAnnotationHeader&& x);
RTPS_DllAPI MinimalAnnotationHeader& operator=(
const MinimalAnnotationHeader& x);
RTPS_DllAPI MinimalAnnotationHeader& operator=(
MinimalAnnotationHeader&& x);
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAnnotationHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAnnotationHeader&) const { return true; }
RTPS_DllAPI bool consistent(
const MinimalAnnotationHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
};
/*struct CompleteAnnotationType final{
AnnotationTypeFlag annotation_flag;
CompleteAnnotationHeader header;
CompleteAnnotationParameterSeq member_seq;
};*/
class CompleteAnnotationType final
{
public:
RTPS_DllAPI CompleteAnnotationType();
RTPS_DllAPI ~CompleteAnnotationType();
RTPS_DllAPI CompleteAnnotationType(
const CompleteAnnotationType& x);
RTPS_DllAPI CompleteAnnotationType(
CompleteAnnotationType&& x);
RTPS_DllAPI CompleteAnnotationType& operator=(
const CompleteAnnotationType& x);
RTPS_DllAPI CompleteAnnotationType& operator=(
CompleteAnnotationType&& x);
RTPS_DllAPI inline void annotation_flag(
const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
RTPS_DllAPI inline void annotation_flag(
AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
RTPS_DllAPI inline void header(
const CompleteAnnotationHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteAnnotationHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteAnnotationHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteAnnotationHeader& header() { return m_header; }
RTPS_DllAPI inline void member_seq(
const CompleteAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
CompleteAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const CompleteAnnotationParameterSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline CompleteAnnotationParameterSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAnnotationType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAnnotationType& other) const;
RTPS_DllAPI bool consistent(
const CompleteAnnotationType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AnnotationTypeFlag m_annotation_flag;
CompleteAnnotationHeader m_header;
CompleteAnnotationParameterSeq m_member_seq;
};
/*struct MinimalAnnotationType final{
AnnotationTypeFlag annotation_flag;
MinimalAnnotationHeader header;
MinimalAnnotationParameterSeq member_seq;
};*/
class MinimalAnnotationType final
{
public:
RTPS_DllAPI MinimalAnnotationType();
RTPS_DllAPI ~MinimalAnnotationType();
RTPS_DllAPI MinimalAnnotationType(
const MinimalAnnotationType& x);
RTPS_DllAPI MinimalAnnotationType(
MinimalAnnotationType&& x);
RTPS_DllAPI MinimalAnnotationType& operator=(
const MinimalAnnotationType& x);
RTPS_DllAPI MinimalAnnotationType& operator=(
MinimalAnnotationType&& x);
RTPS_DllAPI inline void annotation_flag(
const AnnotationTypeFlag& _annotation_flag) { m_annotation_flag = _annotation_flag; }
RTPS_DllAPI inline void annotation_flag(
AnnotationTypeFlag&& _annotation_flag) { m_annotation_flag = std::move(_annotation_flag); }
RTPS_DllAPI inline const AnnotationTypeFlag& annotation_flag() const { return m_annotation_flag; }
RTPS_DllAPI inline AnnotationTypeFlag& annotation_flag() { return m_annotation_flag; }
RTPS_DllAPI inline void header(
const MinimalAnnotationHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalAnnotationHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalAnnotationHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalAnnotationHeader& header() { return m_header; }
RTPS_DllAPI inline void member_seq(
const MinimalAnnotationParameterSeq& _member_seq) { m_member_seq = _member_seq; }
RTPS_DllAPI inline void member_seq(
MinimalAnnotationParameterSeq&& _member_seq) { m_member_seq = std::move(_member_seq); }
RTPS_DllAPI inline const MinimalAnnotationParameterSeq& member_seq() const { return m_member_seq; }
RTPS_DllAPI inline MinimalAnnotationParameterSeq& member_seq() { return m_member_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAnnotationType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAnnotationType& other) const;
RTPS_DllAPI bool consistent(
const MinimalAnnotationType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AnnotationTypeFlag m_annotation_flag;
MinimalAnnotationHeader m_header;
MinimalAnnotationParameterSeq m_member_seq;
};
// --- Alias: ---------------------------------------------------------
/*struct CommonAliasBody final{
AliasMemberFlag related_flags;
TypeIdentifier related_type;
};*/
class CommonAliasBody
{
public:
RTPS_DllAPI CommonAliasBody();
RTPS_DllAPI ~CommonAliasBody();
RTPS_DllAPI CommonAliasBody(
const CommonAliasBody& x);
RTPS_DllAPI CommonAliasBody(
CommonAliasBody&& x);
RTPS_DllAPI CommonAliasBody& operator=(
const CommonAliasBody& x);
RTPS_DllAPI CommonAliasBody& operator=(
CommonAliasBody&& x);
RTPS_DllAPI inline void related_flags(
const AliasMemberFlag& _related_flags) { m_related_flags = _related_flags; }
RTPS_DllAPI inline void related_flags(
AliasMemberFlag&& _related_flags) { m_related_flags = std::move(_related_flags); }
RTPS_DllAPI inline const AliasMemberFlag& related_flags() const { return m_related_flags; }
RTPS_DllAPI inline AliasMemberFlag& related_flags() { return m_related_flags; }
RTPS_DllAPI inline void related_type(
const TypeIdentifier& _related_type) { m_related_type = _related_type; }
RTPS_DllAPI inline void related_type(
TypeIdentifier&& _related_type) { m_related_type = std::move(_related_type); }
RTPS_DllAPI inline const TypeIdentifier& related_type() const { return m_related_type; }
RTPS_DllAPI inline TypeIdentifier& related_type() { return m_related_type; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonAliasBody& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonAliasBody& other) const;
// RTPS_DllAPI bool consistent(const CommonAliasBody &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AliasMemberFlag m_related_flags;
TypeIdentifier m_related_type;
};
/*struct CompleteAliasBody {
CommonAliasBody common;
AppliedBuiltinMemberAnnotations ann_builtin; // Optional
AppliedAnnotationSeq ann_custom; // Optional
};*/
class CompleteAliasBody
{
public:
RTPS_DllAPI CompleteAliasBody();
RTPS_DllAPI ~CompleteAliasBody();
RTPS_DllAPI CompleteAliasBody(
const CompleteAliasBody& x);
RTPS_DllAPI CompleteAliasBody(
CompleteAliasBody&& x);
RTPS_DllAPI CompleteAliasBody& operator=(
const CompleteAliasBody& x);
RTPS_DllAPI CompleteAliasBody& operator=(
CompleteAliasBody&& x);
RTPS_DllAPI inline void common(
const CommonAliasBody& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonAliasBody&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
RTPS_DllAPI inline void ann_builtin(
const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
RTPS_DllAPI inline void ann_builtin(
AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
RTPS_DllAPI inline void ann_custom(
const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
RTPS_DllAPI inline void ann_custom(
AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAliasBody& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAliasBody& other) const;
// RTPS_DllAPI bool consistent(const CompleteAliasBody &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonAliasBody m_common;
AppliedBuiltinMemberAnnotations m_ann_builtin;
AppliedAnnotationSeq m_ann_custom;
};
/*struct MinimalAliasBody {
CommonAliasBody common;
};*/
class MinimalAliasBody
{
public:
RTPS_DllAPI MinimalAliasBody();
RTPS_DllAPI ~MinimalAliasBody();
RTPS_DllAPI MinimalAliasBody(
const MinimalAliasBody& x);
RTPS_DllAPI MinimalAliasBody(
MinimalAliasBody&& x);
RTPS_DllAPI MinimalAliasBody& operator=(
const MinimalAliasBody& x);
RTPS_DllAPI MinimalAliasBody& operator=(
MinimalAliasBody&& x);
RTPS_DllAPI inline void common(
const CommonAliasBody& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonAliasBody&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonAliasBody& common() const { return m_common; }
RTPS_DllAPI inline CommonAliasBody& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAliasBody& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAliasBody& other) const;
// RTPS_DllAPI bool consistent(const MinimalAliasBody &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonAliasBody m_common;
};
/*struct CompleteAliasHeader {
CompleteTypeDetail detail;
};*/
class CompleteAliasHeader
{
public:
RTPS_DllAPI CompleteAliasHeader();
RTPS_DllAPI ~CompleteAliasHeader();
RTPS_DllAPI CompleteAliasHeader(
const CompleteAliasHeader& x);
RTPS_DllAPI CompleteAliasHeader(
CompleteAliasHeader&& x);
RTPS_DllAPI CompleteAliasHeader& operator=(
const CompleteAliasHeader& x);
RTPS_DllAPI CompleteAliasHeader& operator=(
CompleteAliasHeader&& x);
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAliasHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAliasHeader& other) const;
// RTPS_DllAPI bool consistent(const CompleteAliasHeader &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CompleteTypeDetail m_detail;
};
/*struct MinimalAliasHeader {
// Empty. Available for future extension
};*/
class MinimalAliasHeader
{
public:
RTPS_DllAPI MinimalAliasHeader();
RTPS_DllAPI ~MinimalAliasHeader();
RTPS_DllAPI MinimalAliasHeader(
const MinimalAliasHeader& x);
RTPS_DllAPI MinimalAliasHeader(
MinimalAliasHeader&& x);
RTPS_DllAPI MinimalAliasHeader& operator=(
const MinimalAliasHeader& x);
RTPS_DllAPI MinimalAliasHeader& operator=(
MinimalAliasHeader&& x);
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAliasHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAliasHeader&) const { return true; }
// RTPS_DllAPI bool consistent(const MinimalAliasHeader &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
};
/*struct CompleteAliasType final{
AliasTypeFlag alias_flags;
CompleteAliasHeader header;
CompleteAliasBody body;
};*/
class CompleteAliasType
{
public:
RTPS_DllAPI CompleteAliasType();
RTPS_DllAPI ~CompleteAliasType();
RTPS_DllAPI CompleteAliasType(
const CompleteAliasType& x);
RTPS_DllAPI CompleteAliasType(
CompleteAliasType&& x);
RTPS_DllAPI CompleteAliasType& operator=(
const CompleteAliasType& x);
RTPS_DllAPI CompleteAliasType& operator=(
CompleteAliasType&& x);
RTPS_DllAPI inline void alias_flags(
const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
RTPS_DllAPI inline void alias_flags(
AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
RTPS_DllAPI inline void header(
const CompleteAliasHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteAliasHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteAliasHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteAliasHeader& header() { return m_header; }
RTPS_DllAPI inline void body(
const CompleteAliasBody& _body) { m_body = _body; }
RTPS_DllAPI inline void body(
CompleteAliasBody&& _body) { m_body = std::move(_body); }
RTPS_DllAPI inline const CompleteAliasBody& body() const { return m_body; }
RTPS_DllAPI inline CompleteAliasBody& body() { return m_body; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteAliasType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteAliasType& other) const;
// RTPS_DllAPI bool consistent(const CompleteAliasType &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AliasTypeFlag m_alias_flags;
CompleteAliasHeader m_header;
CompleteAliasBody m_body;
};
/*struct MinimalAliasType final{
AliasTypeFlag alias_flags;
MinimalAliasHeader header;
MinimalAliasBody body;
};*/
class MinimalAliasType
{
public:
RTPS_DllAPI MinimalAliasType();
RTPS_DllAPI ~MinimalAliasType();
RTPS_DllAPI MinimalAliasType(
const MinimalAliasType& x);
RTPS_DllAPI MinimalAliasType(
MinimalAliasType&& x);
RTPS_DllAPI MinimalAliasType& operator=(
const MinimalAliasType& x);
RTPS_DllAPI MinimalAliasType& operator=(
MinimalAliasType&& x);
RTPS_DllAPI inline void alias_flags(
const AliasTypeFlag& _alias_flags) { m_alias_flags = _alias_flags; }
RTPS_DllAPI inline void alias_flags(
AliasTypeFlag&& _alias_flags) { m_alias_flags = std::move(_alias_flags); }
RTPS_DllAPI inline const AliasTypeFlag& alias_flags() const { return m_alias_flags; }
RTPS_DllAPI inline AliasTypeFlag& alias_flags() { return m_alias_flags; }
RTPS_DllAPI inline void header(
const MinimalAliasHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalAliasHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalAliasHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalAliasHeader& header() { return m_header; }
RTPS_DllAPI inline void body(
const MinimalAliasBody& _body) { m_body = _body; }
RTPS_DllAPI inline void body(
MinimalAliasBody&& _body) { m_body = std::move(_body); }
RTPS_DllAPI inline const MinimalAliasBody& body() const { return m_body; }
RTPS_DllAPI inline MinimalAliasBody& body() { return m_body; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalAliasType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalAliasType& other) const;
// RTPS_DllAPI bool consistent(const MinimalAliasType &x,
// const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AliasTypeFlag m_alias_flags;
MinimalAliasHeader m_header;
MinimalAliasBody m_body;
};
// --- Collections: ---------------------------------------------------
/*struct CompleteElementDetail final{
AppliedBuiltinMemberAnnotations ann_builtin; // Optional
AppliedAnnotationSeq ann_custom; // Optional
};*/
class CompleteElementDetail
{
public:
RTPS_DllAPI CompleteElementDetail();
RTPS_DllAPI ~CompleteElementDetail();
RTPS_DllAPI CompleteElementDetail(
const CompleteElementDetail& x);
RTPS_DllAPI CompleteElementDetail(
CompleteElementDetail&& x);
RTPS_DllAPI CompleteElementDetail& operator=(
const CompleteElementDetail& x);
RTPS_DllAPI CompleteElementDetail& operator=(
CompleteElementDetail&& x);
RTPS_DllAPI inline void ann_builtin(
const AppliedBuiltinMemberAnnotations& _ann_builtin) { m_ann_builtin = _ann_builtin; }
RTPS_DllAPI inline void ann_builtin(
AppliedBuiltinMemberAnnotations&& _ann_builtin) { m_ann_builtin = std::move(_ann_builtin); }
RTPS_DllAPI inline const AppliedBuiltinMemberAnnotations& ann_builtin() const { return m_ann_builtin; }
RTPS_DllAPI inline AppliedBuiltinMemberAnnotations& ann_builtin() { return m_ann_builtin; }
RTPS_DllAPI inline void ann_custom(
const AppliedAnnotationSeq& _ann_custom) { m_ann_custom = _ann_custom; }
RTPS_DllAPI inline void ann_custom(
AppliedAnnotationSeq&& _ann_custom) { m_ann_custom = std::move(_ann_custom); }
RTPS_DllAPI inline const AppliedAnnotationSeq& ann_custom() const { return m_ann_custom; }
RTPS_DllAPI inline AppliedAnnotationSeq& ann_custom() { return m_ann_custom; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteElementDetail& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteElementDetail& other) const;
RTPS_DllAPI bool consistent(
const CompleteElementDetail& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
AppliedBuiltinMemberAnnotations m_ann_builtin;
AppliedAnnotationSeq m_ann_custom;
};
/*struct CommonCollectionElement final{
CollectionElementFlag element_flags;
TypeIdentifier type;
};*/
class CommonCollectionElement final
{
public:
RTPS_DllAPI CommonCollectionElement();
RTPS_DllAPI ~CommonCollectionElement();
RTPS_DllAPI CommonCollectionElement(
const CommonCollectionElement& x);
RTPS_DllAPI CommonCollectionElement(
CommonCollectionElement&& x);
RTPS_DllAPI CommonCollectionElement& operator=(
const CommonCollectionElement& x);
RTPS_DllAPI CommonCollectionElement& operator=(
CommonCollectionElement&& x);
RTPS_DllAPI inline void element_flags(
const CollectionElementFlag& _element_flags) { m_element_flags = _element_flags; }
RTPS_DllAPI inline void element_flags(
CollectionElementFlag&& _element_flags) { m_element_flags = std::move(_element_flags); }
RTPS_DllAPI inline const CollectionElementFlag& element_flags() const { return m_element_flags; }
RTPS_DllAPI inline CollectionElementFlag& element_flags() { return m_element_flags; }
RTPS_DllAPI inline void type(
const TypeIdentifier& _type) { m_type = _type; }
RTPS_DllAPI inline void type(
TypeIdentifier&& _type) { m_type = std::move(_type); }
RTPS_DllAPI inline const TypeIdentifier& type() const { return m_type; }
RTPS_DllAPI inline TypeIdentifier& type() { return m_type; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonCollectionElement& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonCollectionElement& other) const;
RTPS_DllAPI bool consistent(
const CommonCollectionElement& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionElementFlag m_element_flags;
TypeIdentifier m_type;
};
/*struct CompleteCollectionElement {
CommonCollectionElement common;
CompleteElementDetail detail;
};*/
class CompleteCollectionElement
{
public:
RTPS_DllAPI CompleteCollectionElement();
RTPS_DllAPI ~CompleteCollectionElement();
RTPS_DllAPI CompleteCollectionElement(
const CompleteCollectionElement& x);
RTPS_DllAPI CompleteCollectionElement(
CompleteCollectionElement&& x);
RTPS_DllAPI CompleteCollectionElement& operator=(
const CompleteCollectionElement& x);
RTPS_DllAPI CompleteCollectionElement& operator=(
CompleteCollectionElement&& x);
RTPS_DllAPI inline void common(
const CommonCollectionElement& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonCollectionElement&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteElementDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteElementDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteElementDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteElementDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteCollectionElement& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteCollectionElement& other) const;
RTPS_DllAPI bool consistent(
const CompleteCollectionElement& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonCollectionElement m_common;
CompleteElementDetail m_detail;
};
/*struct MinimalCollectionElement {
CommonCollectionElement common;
};*/
class MinimalCollectionElement
{
public:
RTPS_DllAPI MinimalCollectionElement();
RTPS_DllAPI ~MinimalCollectionElement();
RTPS_DllAPI MinimalCollectionElement(
const MinimalCollectionElement& x);
RTPS_DllAPI MinimalCollectionElement(
MinimalCollectionElement&& x);
RTPS_DllAPI MinimalCollectionElement& operator=(
const MinimalCollectionElement& x);
RTPS_DllAPI MinimalCollectionElement& operator=(
MinimalCollectionElement&& x);
RTPS_DllAPI inline void common(
const CommonCollectionElement& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonCollectionElement&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonCollectionElement& common() const { return m_common; }
RTPS_DllAPI inline CommonCollectionElement& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalCollectionElement& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalCollectionElement& other) const;
RTPS_DllAPI bool consistent(
const MinimalCollectionElement& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonCollectionElement m_common;
};
/*struct CommonCollectionHeader final{
LBound bound;
};*/
class CommonCollectionHeader
{
public:
RTPS_DllAPI CommonCollectionHeader();
RTPS_DllAPI ~CommonCollectionHeader();
RTPS_DllAPI CommonCollectionHeader(
const CommonCollectionHeader& x);
RTPS_DllAPI CommonCollectionHeader(
CommonCollectionHeader&& x);
RTPS_DllAPI CommonCollectionHeader& operator=(
const CommonCollectionHeader& x);
RTPS_DllAPI CommonCollectionHeader& operator=(
CommonCollectionHeader&& x);
RTPS_DllAPI inline void bound(
const LBound& _bound) { m_bound = _bound; }
RTPS_DllAPI inline void bound(
LBound&& _bound) { m_bound = std::move(_bound); }
RTPS_DllAPI inline const LBound& bound() const { return m_bound; }
RTPS_DllAPI inline LBound& bound() { return m_bound; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonCollectionHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonCollectionHeader& other) const;
RTPS_DllAPI bool consistent(
const CommonCollectionHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
LBound m_bound;
};
/*struct CompleteCollectionHeader {
CommonCollectionHeader common;
CompleteTypeDetail detail; // Optional // not present for anonymous
};*/
class CompleteCollectionHeader
{
public:
RTPS_DllAPI CompleteCollectionHeader();
RTPS_DllAPI ~CompleteCollectionHeader();
RTPS_DllAPI CompleteCollectionHeader(
const CompleteCollectionHeader& x);
RTPS_DllAPI CompleteCollectionHeader(
CompleteCollectionHeader&& x);
RTPS_DllAPI CompleteCollectionHeader& operator=(
const CompleteCollectionHeader& x);
RTPS_DllAPI CompleteCollectionHeader& operator=(
CompleteCollectionHeader&& x);
RTPS_DllAPI inline void common(
const CommonCollectionHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonCollectionHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteCollectionHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteCollectionHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteCollectionHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonCollectionHeader m_common;
CompleteTypeDetail m_detail;
};
/*struct MinimalCollectionHeader {
CommonCollectionHeader common;
};*/
class MinimalCollectionHeader
{
public:
RTPS_DllAPI MinimalCollectionHeader();
RTPS_DllAPI ~MinimalCollectionHeader();
RTPS_DllAPI MinimalCollectionHeader(
const MinimalCollectionHeader& x);
RTPS_DllAPI MinimalCollectionHeader(
MinimalCollectionHeader&& x);
RTPS_DllAPI MinimalCollectionHeader& operator=(
const MinimalCollectionHeader& x);
RTPS_DllAPI MinimalCollectionHeader& operator=(
MinimalCollectionHeader&& x);
RTPS_DllAPI inline void common(
const CommonCollectionHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonCollectionHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonCollectionHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonCollectionHeader& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalCollectionHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalCollectionHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalCollectionHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonCollectionHeader m_common;
};
// --- Sequence: -----------------------------------------------------
/*struct CompleteSequenceType final{
CollectionTypeFlag collection_flag;
CompleteCollectionHeader header;
CompleteCollectionElement element;
};*/
class CompleteSequenceType
{
public:
RTPS_DllAPI CompleteSequenceType();
RTPS_DllAPI ~CompleteSequenceType();
RTPS_DllAPI CompleteSequenceType(
const CompleteSequenceType& x);
RTPS_DllAPI CompleteSequenceType(
CompleteSequenceType&& x);
RTPS_DllAPI CompleteSequenceType& operator=(
const CompleteSequenceType& x);
RTPS_DllAPI CompleteSequenceType& operator=(
CompleteSequenceType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const CompleteCollectionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
RTPS_DllAPI inline void element(
const CompleteCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
CompleteCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteSequenceType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteSequenceType& other) const;
RTPS_DllAPI bool consistent(
const CompleteSequenceType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
CompleteCollectionHeader m_header;
CompleteCollectionElement m_element;
};
/*struct MinimalSequenceType final{
CollectionTypeFlag collection_flag;
MinimalCollectionHeader header;
MinimalCollectionElement element;
};*/
class MinimalSequenceType
{
public:
RTPS_DllAPI MinimalSequenceType();
RTPS_DllAPI ~MinimalSequenceType();
RTPS_DllAPI MinimalSequenceType(
const MinimalSequenceType& x);
RTPS_DllAPI MinimalSequenceType(
MinimalSequenceType&& x);
RTPS_DllAPI MinimalSequenceType& operator=(
const MinimalSequenceType& x);
RTPS_DllAPI MinimalSequenceType& operator=(
MinimalSequenceType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const MinimalCollectionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
RTPS_DllAPI inline void element(
const MinimalCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
MinimalCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalSequenceType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalSequenceType& other) const;
RTPS_DllAPI bool consistent(
const MinimalSequenceType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
MinimalCollectionHeader m_header;
MinimalCollectionElement m_element;
};
// --- Array: -----------------------------------------------------
/*struct CommonArrayHeader final{
LBoundSeq bound_seq;
};*/
class CommonArrayHeader
{
public:
RTPS_DllAPI CommonArrayHeader();
RTPS_DllAPI ~CommonArrayHeader();
RTPS_DllAPI CommonArrayHeader(
const CommonArrayHeader& x);
RTPS_DllAPI CommonArrayHeader(
CommonArrayHeader&& x);
RTPS_DllAPI CommonArrayHeader& operator=(
const CommonArrayHeader& x);
RTPS_DllAPI CommonArrayHeader& operator=(
CommonArrayHeader&& x);
RTPS_DllAPI inline void bound_seq(
const LBoundSeq& _bound_seq) { m_bound_seq = _bound_seq; }
RTPS_DllAPI inline void bound_seq(
LBoundSeq&& _bound_seq) { m_bound_seq = std::move(_bound_seq); }
RTPS_DllAPI inline const LBoundSeq& bound_seq() const { return m_bound_seq; }
RTPS_DllAPI inline LBoundSeq& bound_seq() { return m_bound_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonArrayHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonArrayHeader& other) const;
RTPS_DllAPI bool consistent(
const CommonArrayHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
LBoundSeq m_bound_seq;
};
/*struct CompleteArrayHeader {
CommonArrayHeader common;
CompleteTypeDetail detail;
};*/
class CompleteArrayHeader
{
public:
RTPS_DllAPI CompleteArrayHeader();
RTPS_DllAPI ~CompleteArrayHeader();
RTPS_DllAPI CompleteArrayHeader(
const CompleteArrayHeader& x);
RTPS_DllAPI CompleteArrayHeader(
CompleteArrayHeader&& x);
RTPS_DllAPI CompleteArrayHeader& operator=(
const CompleteArrayHeader& x);
RTPS_DllAPI CompleteArrayHeader& operator=(
CompleteArrayHeader&& x);
RTPS_DllAPI inline void common(
const CommonArrayHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonArrayHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteArrayHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteArrayHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteArrayHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonArrayHeader m_common;
CompleteTypeDetail m_detail;
};
/*struct MinimalArrayHeader {
CommonArrayHeader common;
};*/
class MinimalArrayHeader
{
public:
RTPS_DllAPI MinimalArrayHeader();
RTPS_DllAPI ~MinimalArrayHeader();
RTPS_DllAPI MinimalArrayHeader(
const MinimalArrayHeader& x);
RTPS_DllAPI MinimalArrayHeader(
MinimalArrayHeader&& x);
RTPS_DllAPI MinimalArrayHeader& operator=(
const MinimalArrayHeader& x);
RTPS_DllAPI MinimalArrayHeader& operator=(
MinimalArrayHeader&& x);
RTPS_DllAPI inline void common(
const CommonArrayHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonArrayHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonArrayHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonArrayHeader& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalArrayHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalArrayHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalArrayHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonArrayHeader m_common;
};
/*struct CompleteArrayType {
CollectionTypeFlag collection_flag;
CompleteArrayHeader header;
CompleteCollectionElement element;
};*/
class CompleteArrayType
{
public:
RTPS_DllAPI CompleteArrayType();
RTPS_DllAPI ~CompleteArrayType();
RTPS_DllAPI CompleteArrayType(
const CompleteArrayType& x);
RTPS_DllAPI CompleteArrayType(
CompleteArrayType&& x);
RTPS_DllAPI CompleteArrayType& operator=(
const CompleteArrayType& x);
RTPS_DllAPI CompleteArrayType& operator=(
CompleteArrayType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const CompleteArrayHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteArrayHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteArrayHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteArrayHeader& header() { return m_header; }
RTPS_DllAPI inline void element(
const CompleteCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
CompleteCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteArrayType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteArrayType& other) const;
RTPS_DllAPI bool consistent(
const CompleteArrayType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
CompleteArrayHeader m_header;
CompleteCollectionElement m_element;
};
/*struct MinimalArrayType final{
CollectionTypeFlag collection_flag;
MinimalArrayHeader header;
MinimalCollectionElement element;
};*/
class MinimalArrayType
{
public:
RTPS_DllAPI MinimalArrayType();
RTPS_DllAPI ~MinimalArrayType();
RTPS_DllAPI MinimalArrayType(
const MinimalArrayType& x);
RTPS_DllAPI MinimalArrayType(
MinimalArrayType&& x);
RTPS_DllAPI MinimalArrayType& operator=(
const MinimalArrayType& x);
RTPS_DllAPI MinimalArrayType& operator=(
MinimalArrayType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const MinimalArrayHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalArrayHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalArrayHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalArrayHeader& header() { return m_header; }
RTPS_DllAPI inline void element(
const MinimalCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
MinimalCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalArrayType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalArrayType& other) const;
RTPS_DllAPI bool consistent(
const MinimalArrayType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
MinimalArrayHeader m_header;
MinimalCollectionElement m_element;
};
// --- Map: -----------------------------------------------------
/*struct CompleteMapType final{
CollectionTypeFlag collection_flag;
CompleteCollectionHeader header;
CompleteCollectionElement key;
CompleteCollectionElement element;
};*/
class CompleteMapType final
{
public:
RTPS_DllAPI CompleteMapType();
RTPS_DllAPI ~CompleteMapType();
RTPS_DllAPI CompleteMapType(
const CompleteMapType& x);
RTPS_DllAPI CompleteMapType(
CompleteMapType&& x);
RTPS_DllAPI CompleteMapType& operator=(
const CompleteMapType& x);
RTPS_DllAPI CompleteMapType& operator=(
CompleteMapType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const CompleteCollectionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteCollectionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteCollectionHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteCollectionHeader& header() { return m_header; }
RTPS_DllAPI inline void key(
const CompleteCollectionElement& _key) { m_key = _key; }
RTPS_DllAPI inline void key(
CompleteCollectionElement&& _key) { m_key = std::move(_key); }
RTPS_DllAPI inline const CompleteCollectionElement& key() const { return m_key; }
RTPS_DllAPI inline CompleteCollectionElement& key() { return m_key; }
RTPS_DllAPI inline void element(
const CompleteCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
CompleteCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const CompleteCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline CompleteCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteMapType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteMapType& other) const;
RTPS_DllAPI bool consistent(
const CompleteMapType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
CompleteCollectionHeader m_header;
CompleteCollectionElement m_key;
CompleteCollectionElement m_element;
};
/*struct MinimalMapType final{
CollectionTypeFlag collection_flag;
MinimalCollectionHeader header;
MinimalCollectionElement key;
MinimalCollectionElement element;
};*/
class MinimalMapType final
{
public:
RTPS_DllAPI MinimalMapType();
RTPS_DllAPI ~MinimalMapType();
RTPS_DllAPI MinimalMapType(
const MinimalMapType& x);
RTPS_DllAPI MinimalMapType(
MinimalMapType&& x);
RTPS_DllAPI MinimalMapType& operator=(
const MinimalMapType& x);
RTPS_DllAPI MinimalMapType& operator=(
MinimalMapType&& x);
RTPS_DllAPI inline void collection_flag(
const CollectionTypeFlag& _collection_flag) { m_collection_flag = _collection_flag; }
RTPS_DllAPI inline void collection_flag(
CollectionTypeFlag&& _collection_flag) { m_collection_flag = std::move(_collection_flag); }
RTPS_DllAPI inline const CollectionTypeFlag& collection_flag() const { return m_collection_flag; }
RTPS_DllAPI inline CollectionTypeFlag& collection_flag() { return m_collection_flag; }
RTPS_DllAPI inline void header(
const MinimalCollectionHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalCollectionHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalCollectionHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalCollectionHeader& header() { return m_header; }
RTPS_DllAPI inline void key(
const MinimalCollectionElement& _key) { m_key = _key; }
RTPS_DllAPI inline void key(
MinimalCollectionElement&& _key) { m_key = std::move(_key); }
RTPS_DllAPI inline const MinimalCollectionElement& key() const { return m_key; }
RTPS_DllAPI inline MinimalCollectionElement& key() { return m_key; }
RTPS_DllAPI inline void element(
const MinimalCollectionElement& _element) { m_element = _element; }
RTPS_DllAPI inline void element(
MinimalCollectionElement&& _element) { m_element = std::move(_element); }
RTPS_DllAPI inline const MinimalCollectionElement& element() const { return m_element; }
RTPS_DllAPI inline MinimalCollectionElement& element() { return m_element; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalMapType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalMapType& other) const;
RTPS_DllAPI bool consistent(
const MinimalMapType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CollectionTypeFlag m_collection_flag;
MinimalCollectionHeader m_header;
MinimalCollectionElement m_key;
MinimalCollectionElement m_element;
};
// --- Enumeration: ---------------------------------------------------
typedef uint16_t BitBound;
// Constant in an enumerated type
/*struct CommonEnumeratedLiteral {
int32_t value;
EnumeratedLiteralFlag flags;
};*/
class CommonEnumeratedLiteral
{
public:
RTPS_DllAPI CommonEnumeratedLiteral();
RTPS_DllAPI ~CommonEnumeratedLiteral();
RTPS_DllAPI CommonEnumeratedLiteral(
const CommonEnumeratedLiteral& x);
RTPS_DllAPI CommonEnumeratedLiteral(
CommonEnumeratedLiteral&& x);
RTPS_DllAPI CommonEnumeratedLiteral& operator=(
const CommonEnumeratedLiteral& x);
RTPS_DllAPI CommonEnumeratedLiteral& operator=(
CommonEnumeratedLiteral&& x);
RTPS_DllAPI inline void value(
const int32_t& _value) { m_value = _value; }
RTPS_DllAPI inline void value(
int32_t&& _value) { m_value = std::move(_value); }
RTPS_DllAPI inline const int32_t& value() const { return m_value; }
RTPS_DllAPI inline int32_t& value() { return m_value; }
RTPS_DllAPI inline void flags(
const EnumeratedLiteralFlag& _flags) { m_flags = _flags; }
RTPS_DllAPI inline void flags(
EnumeratedLiteralFlag&& _flags) { m_flags = std::move(_flags); }
RTPS_DllAPI inline const EnumeratedLiteralFlag& flags() const { return m_flags; }
RTPS_DllAPI inline EnumeratedLiteralFlag& flags() { return m_flags; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonEnumeratedLiteral& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonEnumeratedLiteral& other) const;
RTPS_DllAPI bool consistent(
const CommonEnumeratedLiteral& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
int32_t m_value;
EnumeratedLiteralFlag m_flags;
};
// Constant in an enumerated type
/*struct CompleteEnumeratedLiteral {
CommonEnumeratedLiteral common;
CompleteMemberDetail detail;
};*/
class CompleteEnumeratedLiteral
{
public:
RTPS_DllAPI CompleteEnumeratedLiteral();
RTPS_DllAPI ~CompleteEnumeratedLiteral();
RTPS_DllAPI CompleteEnumeratedLiteral(
const CompleteEnumeratedLiteral& x);
RTPS_DllAPI CompleteEnumeratedLiteral(
CompleteEnumeratedLiteral&& x);
RTPS_DllAPI CompleteEnumeratedLiteral& operator=(
const CompleteEnumeratedLiteral& x);
RTPS_DllAPI CompleteEnumeratedLiteral& operator=(
CompleteEnumeratedLiteral&& x);
RTPS_DllAPI inline void common(
const CommonEnumeratedLiteral& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteEnumeratedLiteral& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteEnumeratedLiteral& other) const;
RTPS_DllAPI bool consistent(
const CompleteEnumeratedLiteral& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonEnumeratedLiteral m_common;
CompleteMemberDetail m_detail;
};
// Ordered by EnumeratedLiteral.common.value
typedef std::vector<CompleteEnumeratedLiteral> CompleteEnumeratedLiteralSeq;
// Constant in an enumerated type
/*struct MinimalEnumeratedLiteral {
CommonEnumeratedLiteral common;
MinimalMemberDetail detail;
};*/
class MinimalEnumeratedLiteral
{
public:
RTPS_DllAPI MinimalEnumeratedLiteral();
RTPS_DllAPI ~MinimalEnumeratedLiteral();
RTPS_DllAPI MinimalEnumeratedLiteral(
const MinimalEnumeratedLiteral& x);
RTPS_DllAPI MinimalEnumeratedLiteral(
MinimalEnumeratedLiteral&& x);
RTPS_DllAPI MinimalEnumeratedLiteral& operator=(
const MinimalEnumeratedLiteral& x);
RTPS_DllAPI MinimalEnumeratedLiteral& operator=(
MinimalEnumeratedLiteral&& x);
RTPS_DllAPI inline void common(
const CommonEnumeratedLiteral& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonEnumeratedLiteral&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonEnumeratedLiteral& common() const { return m_common; }
RTPS_DllAPI inline CommonEnumeratedLiteral& common() { return m_common; }
RTPS_DllAPI inline void detail(
const MinimalMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalEnumeratedLiteral& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalEnumeratedLiteral& other) const;
RTPS_DllAPI bool consistent(
const MinimalEnumeratedLiteral& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonEnumeratedLiteral m_common;
MinimalMemberDetail m_detail;
};
// Ordered by EnumeratedLiteral.common.value
typedef std::vector<MinimalEnumeratedLiteral> MinimalEnumeratedLiteralSeq;
/*struct CommonEnumeratedHeader final{
BitBound bit_bound;
};*/
class CommonEnumeratedHeader final
{
public:
RTPS_DllAPI CommonEnumeratedHeader();
RTPS_DllAPI ~CommonEnumeratedHeader();
RTPS_DllAPI CommonEnumeratedHeader(
const CommonEnumeratedHeader& x);
RTPS_DllAPI CommonEnumeratedHeader(
CommonEnumeratedHeader&& x);
RTPS_DllAPI CommonEnumeratedHeader& operator=(
const CommonEnumeratedHeader& x);
RTPS_DllAPI CommonEnumeratedHeader& operator=(
CommonEnumeratedHeader&& x);
RTPS_DllAPI inline void bit_bound(
const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
RTPS_DllAPI inline void bit_bound(
BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonEnumeratedHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonEnumeratedHeader& other) const;
RTPS_DllAPI bool consistent(
const CommonEnumeratedHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitBound m_bit_bound;
};
/*struct CompleteEnumeratedHeader {
CommonEnumeratedHeader common;
CompleteTypeDetail detail;
};*/
class CompleteEnumeratedHeader
{
public:
RTPS_DllAPI CompleteEnumeratedHeader();
RTPS_DllAPI ~CompleteEnumeratedHeader();
RTPS_DllAPI CompleteEnumeratedHeader(
const CompleteEnumeratedHeader& x);
RTPS_DllAPI CompleteEnumeratedHeader(
CompleteEnumeratedHeader&& x);
RTPS_DllAPI CompleteEnumeratedHeader& operator=(
const CompleteEnumeratedHeader& x);
RTPS_DllAPI CompleteEnumeratedHeader& operator=(
CompleteEnumeratedHeader&& x);
RTPS_DllAPI inline void common(
const CommonEnumeratedHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteEnumeratedHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteEnumeratedHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteEnumeratedHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonEnumeratedHeader m_common;
CompleteTypeDetail m_detail;
};
/*struct MinimalEnumeratedHeader {
CommonEnumeratedHeader common;
};*/
class MinimalEnumeratedHeader
{
public:
RTPS_DllAPI MinimalEnumeratedHeader();
RTPS_DllAPI ~MinimalEnumeratedHeader();
RTPS_DllAPI MinimalEnumeratedHeader(
const MinimalEnumeratedHeader& x);
RTPS_DllAPI MinimalEnumeratedHeader(
MinimalEnumeratedHeader&& x);
RTPS_DllAPI MinimalEnumeratedHeader& operator=(
const MinimalEnumeratedHeader& x);
RTPS_DllAPI MinimalEnumeratedHeader& operator=(
MinimalEnumeratedHeader&& x);
RTPS_DllAPI inline void common(
const CommonEnumeratedHeader& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonEnumeratedHeader&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonEnumeratedHeader& common() const { return m_common; }
RTPS_DllAPI inline CommonEnumeratedHeader& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalEnumeratedHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalEnumeratedHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalEnumeratedHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonEnumeratedHeader m_common;
};
// Enumerated type
/*struct CompleteEnumeratedType final{
EnumTypeFlag enum_flags; // unused
CompleteEnumeratedHeader header;
CompleteEnumeratedLiteralSeq literal_seq;
};*/
class CompleteEnumeratedType
{
public:
RTPS_DllAPI CompleteEnumeratedType();
RTPS_DllAPI ~CompleteEnumeratedType();
RTPS_DllAPI CompleteEnumeratedType(
const CompleteEnumeratedType& x);
RTPS_DllAPI CompleteEnumeratedType(
CompleteEnumeratedType&& x);
RTPS_DllAPI CompleteEnumeratedType& operator=(
const CompleteEnumeratedType& x);
RTPS_DllAPI CompleteEnumeratedType& operator=(
CompleteEnumeratedType&& x);
RTPS_DllAPI inline void enum_flags(
const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
RTPS_DllAPI inline void enum_flags(
EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
RTPS_DllAPI inline void header(
const CompleteEnumeratedHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteEnumeratedHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteEnumeratedHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteEnumeratedHeader& header() { return m_header; }
RTPS_DllAPI inline void literal_seq(
const CompleteEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
RTPS_DllAPI inline void literal_seq(
CompleteEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
RTPS_DllAPI inline const CompleteEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
RTPS_DllAPI inline CompleteEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteEnumeratedType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteEnumeratedType& other) const;
RTPS_DllAPI bool consistent(
const CompleteEnumeratedType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
EnumTypeFlag m_enum_flags;
CompleteEnumeratedHeader m_header;
CompleteEnumeratedLiteralSeq m_literal_seq;
};
// Enumerated type
/*struct MinimalEnumeratedType final{
EnumTypeFlag enum_flags; // unused
MinimalEnumeratedHeader header;
MinimalEnumeratedLiteralSeq literal_seq;
};*/
class MinimalEnumeratedType
{
public:
RTPS_DllAPI MinimalEnumeratedType();
RTPS_DllAPI ~MinimalEnumeratedType();
RTPS_DllAPI MinimalEnumeratedType(
const MinimalEnumeratedType& x);
RTPS_DllAPI MinimalEnumeratedType(
MinimalEnumeratedType&& x);
RTPS_DllAPI MinimalEnumeratedType& operator=(
const MinimalEnumeratedType& x);
RTPS_DllAPI MinimalEnumeratedType& operator=(
MinimalEnumeratedType&& x);
RTPS_DllAPI inline void enum_flags(
const EnumTypeFlag& _enum_flags) { m_enum_flags = _enum_flags; }
RTPS_DllAPI inline void enum_flags(
EnumTypeFlag&& _enum_flags) { m_enum_flags = std::move(_enum_flags); }
RTPS_DllAPI inline const EnumTypeFlag& enum_flags() const { return m_enum_flags; }
RTPS_DllAPI inline EnumTypeFlag& enum_flags() { return m_enum_flags; }
RTPS_DllAPI inline void header(
const MinimalEnumeratedHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalEnumeratedHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalEnumeratedHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalEnumeratedHeader& header() { return m_header; }
RTPS_DllAPI inline void literal_seq(
const MinimalEnumeratedLiteralSeq& _literal_seq) { m_literal_seq = _literal_seq; }
RTPS_DllAPI inline void literal_seq(
MinimalEnumeratedLiteralSeq&& _literal_seq) { m_literal_seq = std::move(_literal_seq); }
RTPS_DllAPI inline const MinimalEnumeratedLiteralSeq& literal_seq() const { return m_literal_seq; }
RTPS_DllAPI inline MinimalEnumeratedLiteralSeq& literal_seq() { return m_literal_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalEnumeratedType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalEnumeratedType& other) const;
RTPS_DllAPI bool consistent(
const MinimalEnumeratedType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
EnumTypeFlag m_enum_flags;
MinimalEnumeratedHeader m_header;
MinimalEnumeratedLiteralSeq m_literal_seq;
};
// --- Bitmask: -------------------------------------------------------
// Bit in a bit mask
/*struct CommonBitflag final{
uint16_t position;
BitflagFlag flags;
};*/
class CommonBitflag final
{
public:
RTPS_DllAPI CommonBitflag();
RTPS_DllAPI ~CommonBitflag();
RTPS_DllAPI CommonBitflag(
const CommonBitflag& x);
RTPS_DllAPI CommonBitflag(
CommonBitflag&& x);
RTPS_DllAPI CommonBitflag& operator=(
const CommonBitflag& x);
RTPS_DllAPI CommonBitflag& operator=(
CommonBitflag&& x);
RTPS_DllAPI inline void position(
const uint16_t& _position) { m_position = _position; }
RTPS_DllAPI inline void position(
uint16_t&& _position) { m_position = std::move(_position); }
RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
RTPS_DllAPI inline uint16_t& position() { return m_position; }
RTPS_DllAPI inline void flags(
const BitflagFlag& _flags) { m_flags = _flags; }
RTPS_DllAPI inline void flags(
BitflagFlag&& _flags) { m_flags = std::move(_flags); }
RTPS_DllAPI inline const BitflagFlag& flags() const { return m_flags; }
RTPS_DllAPI inline BitflagFlag& flags() { return m_flags; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonBitflag& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonBitflag& other) const;
RTPS_DllAPI bool consistent(
const CommonBitflag& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
uint16_t m_position;
BitflagFlag m_flags;
};
/*struct CompleteBitflag {
CommonBitflag common;
CompleteMemberDetail detail;
};*/
class CompleteBitflag
{
public:
RTPS_DllAPI CompleteBitflag();
RTPS_DllAPI ~CompleteBitflag();
RTPS_DllAPI CompleteBitflag(
const CompleteBitflag& x);
RTPS_DllAPI CompleteBitflag(
CompleteBitflag&& x);
RTPS_DllAPI CompleteBitflag& operator=(
const CompleteBitflag& x);
RTPS_DllAPI CompleteBitflag& operator=(
CompleteBitflag&& x);
RTPS_DllAPI inline void common(
const CommonBitflag& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonBitflag&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteBitflag& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteBitflag& other) const;
RTPS_DllAPI bool consistent(
const CompleteBitflag& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonBitflag m_common;
CompleteMemberDetail m_detail;
};
// Ordered by Bitflag.position
typedef std::vector<CompleteBitflag> CompleteBitflagSeq;
/*struct MinimalBitflag {
CommonBitflag common;
MinimalMemberDetail detail;
};*/
class MinimalBitflag
{
public:
RTPS_DllAPI MinimalBitflag();
RTPS_DllAPI ~MinimalBitflag();
RTPS_DllAPI MinimalBitflag(
const MinimalBitflag& x);
RTPS_DllAPI MinimalBitflag(
MinimalBitflag&& x);
RTPS_DllAPI MinimalBitflag& operator=(
const MinimalBitflag& x);
RTPS_DllAPI MinimalBitflag& operator=(
MinimalBitflag&& x);
RTPS_DllAPI inline void common(
const CommonBitflag& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonBitflag&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonBitflag& common() const { return m_common; }
RTPS_DllAPI inline CommonBitflag& common() { return m_common; }
RTPS_DllAPI inline void detail(
const MinimalMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
MinimalMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const MinimalMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline MinimalMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalBitflag& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalBitflag& other) const;
RTPS_DllAPI bool consistent(
const MinimalBitflag& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonBitflag m_common;
MinimalMemberDetail m_detail;
};
// Ordered by Bitflag.position
typedef std::vector<MinimalBitflag> MinimalBitflagSeq;
/*struct CommonBitmaskHeader final{
BitBound bit_bound;
};*/
class CommonBitmaskHeader final
{
public:
RTPS_DllAPI CommonBitmaskHeader();
RTPS_DllAPI ~CommonBitmaskHeader();
RTPS_DllAPI CommonBitmaskHeader(
const CommonBitmaskHeader& x);
RTPS_DllAPI CommonBitmaskHeader(
CommonBitmaskHeader&& x);
RTPS_DllAPI CommonBitmaskHeader& operator=(
const CommonBitmaskHeader& x);
RTPS_DllAPI CommonBitmaskHeader& operator=(
CommonBitmaskHeader&& x);
RTPS_DllAPI inline void bit_bound(
const BitBound& _bit_bound) { m_bit_bound = _bit_bound; }
RTPS_DllAPI inline void bit_bound(
BitBound&& _bit_bound) { m_bit_bound = std::move(_bit_bound); }
RTPS_DllAPI inline const BitBound& bit_bound() const { return m_bit_bound; }
RTPS_DllAPI inline BitBound& bit_bound() { return m_bit_bound; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonBitmaskHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonBitmaskHeader& other) const;
RTPS_DllAPI bool consistent(
const CommonBitmaskHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitBound m_bit_bound;
};
typedef CompleteEnumeratedHeader CompleteBitmaskHeader;
typedef MinimalEnumeratedHeader MinimalBitmaskHeader;
/*struct CompleteBitmaskType {
BitmaskTypeFlag bitmask_flags; // unused
CompleteBitmaskHeader header;
CompleteBitflagSeq flag_seq;
};*/
class CompleteBitmaskType
{
public:
RTPS_DllAPI CompleteBitmaskType();
RTPS_DllAPI ~CompleteBitmaskType();
RTPS_DllAPI CompleteBitmaskType(
const CompleteBitmaskType& x);
RTPS_DllAPI CompleteBitmaskType(
CompleteBitmaskType&& x);
RTPS_DllAPI CompleteBitmaskType& operator=(
const CompleteBitmaskType& x);
RTPS_DllAPI CompleteBitmaskType& operator=(
CompleteBitmaskType&& x);
RTPS_DllAPI inline void bitmask_flags(
const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
RTPS_DllAPI inline void bitmask_flags(
BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
RTPS_DllAPI inline void header(
const CompleteBitmaskHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteBitmaskHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteBitmaskHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteBitmaskHeader& header() { return m_header; }
RTPS_DllAPI inline void flag_seq(
const CompleteBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
RTPS_DllAPI inline void flag_seq(
CompleteBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
RTPS_DllAPI inline const CompleteBitflagSeq& flag_seq() const { return m_flag_seq; }
RTPS_DllAPI inline CompleteBitflagSeq& flag_seq() { return m_flag_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteBitmaskType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteBitmaskType& other) const;
RTPS_DllAPI bool consistent(
const CompleteBitmaskType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitmaskTypeFlag m_bitmask_flags;
CompleteBitmaskHeader m_header;
CompleteBitflagSeq m_flag_seq;
};
/*struct MinimalBitmaskType {
BitmaskTypeFlag bitmask_flags; // unused
MinimalBitmaskHeader header;
MinimalBitflagSeq flag_seq;
};*/
class MinimalBitmaskType
{
public:
RTPS_DllAPI MinimalBitmaskType();
RTPS_DllAPI ~MinimalBitmaskType();
RTPS_DllAPI MinimalBitmaskType(
const MinimalBitmaskType& x);
RTPS_DllAPI MinimalBitmaskType(
MinimalBitmaskType&& x);
RTPS_DllAPI MinimalBitmaskType& operator=(
const MinimalBitmaskType& x);
RTPS_DllAPI MinimalBitmaskType& operator=(
MinimalBitmaskType&& x);
RTPS_DllAPI inline void bitmask_flags(
const BitmaskTypeFlag& _bitmask_flags) { m_bitmask_flags = _bitmask_flags; }
RTPS_DllAPI inline void bitmask_flags(
BitmaskTypeFlag&& _bitmask_flags) { m_bitmask_flags = std::move(_bitmask_flags); }
RTPS_DllAPI inline const BitmaskTypeFlag& bitmask_flags() const { return m_bitmask_flags; }
RTPS_DllAPI inline BitmaskTypeFlag& bitmask_flags() { return m_bitmask_flags; }
RTPS_DllAPI inline void header(
const MinimalBitmaskHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalBitmaskHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalBitmaskHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalBitmaskHeader& header() { return m_header; }
RTPS_DllAPI inline void flag_seq(
const MinimalBitflagSeq& _flag_seq) { m_flag_seq = _flag_seq; }
RTPS_DllAPI inline void flag_seq(
MinimalBitflagSeq&& _flag_seq) { m_flag_seq = std::move(_flag_seq); }
RTPS_DllAPI inline const MinimalBitflagSeq& flag_seq() const { return m_flag_seq; }
RTPS_DllAPI inline MinimalBitflagSeq& flag_seq() { return m_flag_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalBitmaskType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalBitmaskType& other) const;
RTPS_DllAPI bool consistent(
const MinimalBitmaskType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitmaskTypeFlag m_bitmask_flags;
MinimalBitmaskHeader m_header;
MinimalBitflagSeq m_flag_seq;
};
// --- Bitset: ---------------------------------------------------------
/*struct CommonBitfield final{
uint16_t position;
BitsetMemberFlag flags;
octet bitcount;
TypeKind holder_type; // Must be primitive integer type
};*/
class CommonBitfield final
{
public:
RTPS_DllAPI CommonBitfield();
RTPS_DllAPI ~CommonBitfield();
RTPS_DllAPI CommonBitfield(
const CommonBitfield& x);
RTPS_DllAPI CommonBitfield(
CommonBitfield&& x);
RTPS_DllAPI CommonBitfield& operator=(
const CommonBitfield& x);
RTPS_DllAPI CommonBitfield& operator=(
CommonBitfield&& x);
RTPS_DllAPI inline void position(
const uint16_t& _position) { m_position = _position; }
RTPS_DllAPI inline void position(
uint16_t&& _position) { m_position = std::move(_position); }
RTPS_DllAPI inline const uint16_t& position() const { return m_position; }
RTPS_DllAPI inline uint16_t& position() { return m_position; }
RTPS_DllAPI inline void flags(
const BitsetMemberFlag& _flags) { m_flags = _flags; }
RTPS_DllAPI inline void flags(
BitsetMemberFlag&& _flags) { m_flags = std::move(_flags); }
RTPS_DllAPI inline const BitsetMemberFlag& flags() const { return m_flags; }
RTPS_DllAPI inline BitsetMemberFlag& flags() { return m_flags; }
RTPS_DllAPI inline void bitcount(
const octet& _bitcount) { m_bitcount = _bitcount; }
RTPS_DllAPI inline void bitcount(
octet&& _bitcount) { m_bitcount = std::move(_bitcount); }
RTPS_DllAPI inline const octet& bitcount() const { return m_bitcount; }
RTPS_DllAPI inline octet& bitcount() { return m_bitcount; }
RTPS_DllAPI inline void holder_type(
const TypeKind& _holder_type) { m_holder_type = _holder_type; }
RTPS_DllAPI inline void holder_type(
TypeKind&& _holder_type) { m_holder_type = std::move(_holder_type); }
RTPS_DllAPI inline const TypeKind& holder_type() const { return m_holder_type; }
RTPS_DllAPI inline TypeKind& holder_type() { return m_holder_type; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CommonBitfield& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CommonBitfield& other) const;
RTPS_DllAPI bool consistent(
const CommonBitfield& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
uint16_t m_position;
BitsetMemberFlag m_flags;
octet m_bitcount;
TypeKind m_holder_type;
};
/*struct CompleteBitfield {
CommonBitfield common;
CompleteMemberDetail detail;
};*/
class CompleteBitfield
{
public:
RTPS_DllAPI CompleteBitfield();
RTPS_DllAPI ~CompleteBitfield();
RTPS_DllAPI CompleteBitfield(
const CompleteBitfield& x);
RTPS_DllAPI CompleteBitfield(
CompleteBitfield&& x);
RTPS_DllAPI CompleteBitfield& operator=(
const CompleteBitfield& x);
RTPS_DllAPI CompleteBitfield& operator=(
CompleteBitfield&& x);
RTPS_DllAPI inline void common(
const CommonBitfield& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonBitfield&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
RTPS_DllAPI inline void detail(
const CompleteMemberDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteMemberDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteMemberDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteMemberDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteBitfield& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteBitfield& other) const;
RTPS_DllAPI bool consistent(
const CompleteBitfield& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonBitfield m_common;
CompleteMemberDetail m_detail;
};
// Ordered by Bitfield.position
typedef std::vector<CompleteBitfield> CompleteBitfieldSeq;
/*struct MinimalBitfield {
CommonBitfield common;
NameHash name_hash;
};*/
class MinimalBitfield
{
public:
RTPS_DllAPI MinimalBitfield();
RTPS_DllAPI ~MinimalBitfield();
RTPS_DllAPI MinimalBitfield(
const MinimalBitfield& x);
RTPS_DllAPI MinimalBitfield(
MinimalBitfield&& x);
RTPS_DllAPI MinimalBitfield& operator=(
const MinimalBitfield& x);
RTPS_DllAPI MinimalBitfield& operator=(
MinimalBitfield&& x);
RTPS_DllAPI inline void name_hash(
const NameHash& _name_hash) { m_name_hash = _name_hash; }
RTPS_DllAPI inline void name_hash(
NameHash&& _name_hash) { m_name_hash = std::move(_name_hash); }
RTPS_DllAPI inline const NameHash& name_hash() const { return m_name_hash; }
RTPS_DllAPI inline NameHash& name_hash() { return m_name_hash; }
RTPS_DllAPI inline void common(
const CommonBitfield& _common) { m_common = _common; }
RTPS_DllAPI inline void common(
CommonBitfield&& _common) { m_common = std::move(_common); }
RTPS_DllAPI inline const CommonBitfield& common() const { return m_common; }
RTPS_DllAPI inline CommonBitfield& common() { return m_common; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalBitfield& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalBitfield& other) const;
RTPS_DllAPI bool consistent(
const MinimalBitfield& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
CommonBitfield m_common;
NameHash m_name_hash;
};
// Ordered by Bitfield.position
typedef std::vector<MinimalBitfield> MinimalBitfieldSeq;
/*struct CompleteBitsetHeader {
CompleteTypeDetail detail;
};*/
class CompleteBitsetHeader
{
public:
RTPS_DllAPI CompleteBitsetHeader();
RTPS_DllAPI ~CompleteBitsetHeader();
RTPS_DllAPI CompleteBitsetHeader(
const CompleteBitsetHeader& x);
RTPS_DllAPI CompleteBitsetHeader(
CompleteBitsetHeader&& x);
RTPS_DllAPI CompleteBitsetHeader& operator=(
const CompleteBitsetHeader& x);
RTPS_DllAPI CompleteBitsetHeader& operator=(
CompleteBitsetHeader&& x);
RTPS_DllAPI inline void base_type(
const TypeIdentifier& _base_type) { m_base_type = _base_type; }
RTPS_DllAPI inline void base_type(
TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
RTPS_DllAPI inline void detail(
const CompleteTypeDetail& _detail) { m_detail = _detail; }
RTPS_DllAPI inline void detail(
CompleteTypeDetail&& _detail) { m_detail = std::move(_detail); }
RTPS_DllAPI inline const CompleteTypeDetail& detail() const { return m_detail; }
RTPS_DllAPI inline CompleteTypeDetail& detail() { return m_detail; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteBitsetHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteBitsetHeader& other) const;
RTPS_DllAPI bool consistent(
const CompleteBitsetHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
TypeIdentifier m_base_type;
CompleteTypeDetail m_detail;
};
/*struct MinimalBitsetHeader {
// Empty. Available for future extension
};*/
class MinimalBitsetHeader
{
public:
RTPS_DllAPI MinimalBitsetHeader();
RTPS_DllAPI ~MinimalBitsetHeader();
RTPS_DllAPI MinimalBitsetHeader(
const MinimalBitsetHeader& x);
RTPS_DllAPI MinimalBitsetHeader(
MinimalBitsetHeader&& x);
RTPS_DllAPI MinimalBitsetHeader& operator=(
const MinimalBitsetHeader& x);
RTPS_DllAPI MinimalBitsetHeader& operator=(
MinimalBitsetHeader&& x);
RTPS_DllAPI inline void base_type(
const TypeIdentifier& _base_type) { m_base_type = _base_type; }
RTPS_DllAPI inline void base_type(
TypeIdentifier&& _base_type) { m_base_type = std::move(_base_type); }
RTPS_DllAPI inline const TypeIdentifier& base_type() const { return m_base_type; }
RTPS_DllAPI inline TypeIdentifier& base_type() { return m_base_type; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalBitsetHeader& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalBitsetHeader& other) const;
RTPS_DllAPI bool consistent(
const MinimalBitsetHeader& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
TypeIdentifier m_base_type;
};
/*struct CompleteBitsetType {
BitsetTypeFlag bitset_flags; // unused
CompleteBitsetHeader header;
CompleteBitfieldSeq field_seq;
};*/
class CompleteBitsetType
{
public:
RTPS_DllAPI CompleteBitsetType();
RTPS_DllAPI ~CompleteBitsetType();
RTPS_DllAPI CompleteBitsetType(
const CompleteBitsetType& x);
RTPS_DllAPI CompleteBitsetType(
CompleteBitsetType&& x);
RTPS_DllAPI CompleteBitsetType& operator=(
const CompleteBitsetType& x);
RTPS_DllAPI CompleteBitsetType& operator=(
CompleteBitsetType&& x);
RTPS_DllAPI inline void bitset_flags(
const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
RTPS_DllAPI inline void bitset_flags(
BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
RTPS_DllAPI inline void header(
const CompleteBitsetHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
CompleteBitsetHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const CompleteBitsetHeader& header() const { return m_header; }
RTPS_DllAPI inline CompleteBitsetHeader& header() { return m_header; }
RTPS_DllAPI inline void field_seq(
const CompleteBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
RTPS_DllAPI inline void field_seq(
CompleteBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
RTPS_DllAPI inline const CompleteBitfieldSeq& field_seq() const { return m_field_seq; }
RTPS_DllAPI inline CompleteBitfieldSeq& field_seq() { return m_field_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteBitsetType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteBitsetType& other) const;
RTPS_DllAPI bool consistent(
const CompleteBitsetType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitsetTypeFlag m_bitset_flags;
CompleteBitsetHeader m_header;
CompleteBitfieldSeq m_field_seq;
};
/*struct MinimalBitsetType {
BitsetTypeFlag bitset_flags; // unused
MinimalBitsetHeader header;
MinimalBitfieldSeq field_seq;
};*/
class MinimalBitsetType
{
public:
RTPS_DllAPI MinimalBitsetType();
RTPS_DllAPI ~MinimalBitsetType();
RTPS_DllAPI MinimalBitsetType(
const MinimalBitsetType& x);
RTPS_DllAPI MinimalBitsetType(
MinimalBitsetType&& x);
RTPS_DllAPI MinimalBitsetType& operator=(
const MinimalBitsetType& x);
RTPS_DllAPI MinimalBitsetType& operator=(
MinimalBitsetType&& x);
RTPS_DllAPI inline void bitset_flags(
const BitsetTypeFlag& _bitset_flags) { m_bitset_flags = _bitset_flags; }
RTPS_DllAPI inline void bitset_flags(
BitsetTypeFlag&& _bitset_flags) { m_bitset_flags = std::move(_bitset_flags); }
RTPS_DllAPI inline const BitsetTypeFlag& bitset_flags() const { return m_bitset_flags; }
RTPS_DllAPI inline BitsetTypeFlag& bitset_flags() { return m_bitset_flags; }
RTPS_DllAPI inline void header(
const MinimalBitsetHeader& _header) { m_header = _header; }
RTPS_DllAPI inline void header(
MinimalBitsetHeader&& _header) { m_header = std::move(_header); }
RTPS_DllAPI inline const MinimalBitsetHeader& header() const { return m_header; }
RTPS_DllAPI inline MinimalBitsetHeader& header() { return m_header; }
RTPS_DllAPI inline void field_seq(
const MinimalBitfieldSeq& _field_seq) { m_field_seq = _field_seq; }
RTPS_DllAPI inline void field_seq(
MinimalBitfieldSeq&& _field_seq) { m_field_seq = std::move(_field_seq); }
RTPS_DllAPI inline const MinimalBitfieldSeq& field_seq() const { return m_field_seq; }
RTPS_DllAPI inline MinimalBitfieldSeq& field_seq() { return m_field_seq; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalBitsetType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalBitsetType& other) const;
RTPS_DllAPI bool consistent(
const MinimalBitsetType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
BitsetTypeFlag m_bitset_flags;
MinimalBitsetHeader m_header;
MinimalBitfieldSeq m_field_seq;
};
// --- Type Object: --------------------------------------------------
// The types associated with each case selection must have extensibility
// kind APPENDABLE or MUTABLE so that they can be extended in the future
/*struct CompleteExtendedType {
// Empty. Available for future extension
};*/
class CompleteExtendedType
{
public:
RTPS_DllAPI CompleteExtendedType();
RTPS_DllAPI ~CompleteExtendedType();
RTPS_DllAPI CompleteExtendedType(
const CompleteExtendedType& x);
RTPS_DllAPI CompleteExtendedType(
CompleteExtendedType&& x);
RTPS_DllAPI CompleteExtendedType& operator=(
const CompleteExtendedType& x);
RTPS_DllAPI CompleteExtendedType& operator=(
CompleteExtendedType&& x);
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteExtendedType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteExtendedType&) const { return true; }
RTPS_DllAPI bool consistent(
const CompleteExtendedType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
};
/*struct MinimalExtendedType {
// Empty. Available for future extension
};*/
class MinimalExtendedType
{
public:
RTPS_DllAPI MinimalExtendedType();
RTPS_DllAPI ~MinimalExtendedType();
RTPS_DllAPI MinimalExtendedType(
const MinimalExtendedType& x);
RTPS_DllAPI MinimalExtendedType(
MinimalExtendedType&& x);
RTPS_DllAPI MinimalExtendedType& operator=(
const MinimalExtendedType& x);
RTPS_DllAPI MinimalExtendedType& operator=(
MinimalExtendedType&& x);
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalExtendedType& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalExtendedType&) const { return true; }
RTPS_DllAPI bool consistent(
const MinimalExtendedType& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
};
class CompleteTypeObject final
{
public:
RTPS_DllAPI CompleteTypeObject();
RTPS_DllAPI ~CompleteTypeObject();
RTPS_DllAPI CompleteTypeObject(
const CompleteTypeObject& x);
RTPS_DllAPI CompleteTypeObject(
CompleteTypeObject&& x);
RTPS_DllAPI CompleteTypeObject& operator=(
const CompleteTypeObject& x);
RTPS_DllAPI CompleteTypeObject& operator=(
CompleteTypeObject&& x);
RTPS_DllAPI void _d(
octet __d);
RTPS_DllAPI octet _d() const;
RTPS_DllAPI octet& _d();
RTPS_DllAPI void alias_type(
CompleteAliasType _alias_type);
RTPS_DllAPI const CompleteAliasType& alias_type() const;
RTPS_DllAPI CompleteAliasType& alias_type();
RTPS_DllAPI void annotation_type(
CompleteAnnotationType _annotation_type);
RTPS_DllAPI const CompleteAnnotationType& annotation_type() const;
RTPS_DllAPI CompleteAnnotationType& annotation_type();
RTPS_DllAPI void struct_type(
CompleteStructType _struct_type);
RTPS_DllAPI const CompleteStructType& struct_type() const;
RTPS_DllAPI CompleteStructType& struct_type();
RTPS_DllAPI void union_type(
CompleteUnionType _union_type);
RTPS_DllAPI const CompleteUnionType& union_type() const;
RTPS_DllAPI CompleteUnionType& union_type();
RTPS_DllAPI void bitset_type(
CompleteBitsetType _bitset_type);
RTPS_DllAPI const CompleteBitsetType& bitset_type() const;
RTPS_DllAPI CompleteBitsetType& bitset_type();
RTPS_DllAPI void sequence_type(
CompleteSequenceType _sequence_type);
RTPS_DllAPI const CompleteSequenceType& sequence_type() const;
RTPS_DllAPI CompleteSequenceType& sequence_type();
RTPS_DllAPI void array_type(
CompleteArrayType _array_type);
RTPS_DllAPI const CompleteArrayType& array_type() const;
RTPS_DllAPI CompleteArrayType& array_type();
RTPS_DllAPI void map_type(
CompleteMapType _map_type);
RTPS_DllAPI const CompleteMapType& map_type() const;
RTPS_DllAPI CompleteMapType& map_type();
RTPS_DllAPI void enumerated_type(
CompleteEnumeratedType _enumerated_type);
RTPS_DllAPI const CompleteEnumeratedType& enumerated_type() const;
RTPS_DllAPI CompleteEnumeratedType& enumerated_type();
RTPS_DllAPI void bitmask_type(
CompleteBitmaskType _bitmask_type);
RTPS_DllAPI const CompleteBitmaskType& bitmask_type() const;
RTPS_DllAPI CompleteBitmaskType& bitmask_type();
RTPS_DllAPI void extended_type(
CompleteExtendedType _extended_type);
RTPS_DllAPI const CompleteExtendedType& extended_type() const;
RTPS_DllAPI CompleteExtendedType& extended_type();
RTPS_DllAPI static size_t getCdrSerializedSize(
const CompleteTypeObject& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const CompleteTypeObject& other) const;
RTPS_DllAPI bool consistent(
const CompleteTypeObject& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
octet m__d;
CompleteAliasType m_alias_type;
CompleteAnnotationType m_annotation_type;
CompleteStructType m_struct_type;
CompleteUnionType m_union_type;
CompleteBitsetType m_bitset_type;
CompleteSequenceType m_sequence_type;
CompleteArrayType m_array_type;
CompleteMapType m_map_type;
CompleteEnumeratedType m_enumerated_type;
CompleteBitmaskType m_bitmask_type;
CompleteExtendedType m_extended_type;
};
class MinimalTypeObject final
{
public:
RTPS_DllAPI MinimalTypeObject();
RTPS_DllAPI ~MinimalTypeObject();
RTPS_DllAPI MinimalTypeObject(
const MinimalTypeObject& x);
RTPS_DllAPI MinimalTypeObject(
MinimalTypeObject&& x);
RTPS_DllAPI MinimalTypeObject& operator=(
const MinimalTypeObject& x);
RTPS_DllAPI MinimalTypeObject& operator=(
MinimalTypeObject&& x);
RTPS_DllAPI void _d(
octet __d);
RTPS_DllAPI octet _d() const;
RTPS_DllAPI octet& _d();
RTPS_DllAPI void alias_type(
MinimalAliasType _alias_type);
RTPS_DllAPI const MinimalAliasType& alias_type() const;
RTPS_DllAPI MinimalAliasType& alias_type();
RTPS_DllAPI void annotation_type(
MinimalAnnotationType _annotation_type);
RTPS_DllAPI const MinimalAnnotationType& annotation_type() const;
RTPS_DllAPI MinimalAnnotationType& annotation_type();
RTPS_DllAPI void struct_type(
MinimalStructType _struct_type);
RTPS_DllAPI const MinimalStructType& struct_type() const;
RTPS_DllAPI MinimalStructType& struct_type();
RTPS_DllAPI void union_type(
MinimalUnionType _union_type);
RTPS_DllAPI const MinimalUnionType& union_type() const;
RTPS_DllAPI MinimalUnionType& union_type();
RTPS_DllAPI void bitset_type(
MinimalBitsetType _bitset_type);
RTPS_DllAPI const MinimalBitsetType& bitset_type() const;
RTPS_DllAPI MinimalBitsetType& bitset_type();
RTPS_DllAPI void sequence_type(
MinimalSequenceType _sequence_type);
RTPS_DllAPI const MinimalSequenceType& sequence_type() const;
RTPS_DllAPI MinimalSequenceType& sequence_type();
RTPS_DllAPI void array_type(
MinimalArrayType _array_type);
RTPS_DllAPI const MinimalArrayType& array_type() const;
RTPS_DllAPI MinimalArrayType& array_type();
RTPS_DllAPI void map_type(
MinimalMapType _map_type);
RTPS_DllAPI const MinimalMapType& map_type() const;
RTPS_DllAPI MinimalMapType& map_type();
RTPS_DllAPI void enumerated_type(
MinimalEnumeratedType _enumerated_type);
RTPS_DllAPI const MinimalEnumeratedType& enumerated_type() const;
RTPS_DllAPI MinimalEnumeratedType& enumerated_type();
RTPS_DllAPI void bitmask_type(
MinimalBitmaskType _bitmask_type);
RTPS_DllAPI const MinimalBitmaskType& bitmask_type() const;
RTPS_DllAPI MinimalBitmaskType& bitmask_type();
RTPS_DllAPI void extended_type(
MinimalExtendedType _extended_type);
RTPS_DllAPI const MinimalExtendedType& extended_type() const;
RTPS_DllAPI MinimalExtendedType& extended_type();
RTPS_DllAPI static size_t getCdrSerializedSize(
const MinimalTypeObject& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const MinimalTypeObject& other) const;
RTPS_DllAPI bool consistent(
const MinimalTypeObject& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
octet m__d;
MinimalAliasType m_alias_type;
MinimalAnnotationType m_annotation_type;
MinimalStructType m_struct_type;
MinimalUnionType m_union_type;
MinimalBitsetType m_bitset_type;
MinimalSequenceType m_sequence_type;
MinimalArrayType m_array_type;
MinimalMapType m_map_type;
MinimalEnumeratedType m_enumerated_type;
MinimalBitmaskType m_bitmask_type;
MinimalExtendedType m_extended_type;
};
class TypeObject
{
public:
RTPS_DllAPI TypeObject();
RTPS_DllAPI ~TypeObject();
RTPS_DllAPI TypeObject(
const TypeObject& x);
RTPS_DllAPI TypeObject(
TypeObject&& x);
RTPS_DllAPI TypeObject& operator=(
const TypeObject& x);
RTPS_DllAPI TypeObject& operator=(
TypeObject&& x);
RTPS_DllAPI void _d(
uint8_t __d);
RTPS_DllAPI uint8_t _d() const;
RTPS_DllAPI uint8_t& _d();
RTPS_DllAPI void complete(
const CompleteTypeObject& _complete);
RTPS_DllAPI void complete(
CompleteTypeObject&& _complete);
RTPS_DllAPI const CompleteTypeObject& complete() const;
RTPS_DllAPI CompleteTypeObject& complete();
RTPS_DllAPI void minimal(
const MinimalTypeObject& _minimal);
RTPS_DllAPI void minimal(
MinimalTypeObject&& _minimal);
RTPS_DllAPI const MinimalTypeObject& minimal() const;
RTPS_DllAPI MinimalTypeObject& minimal();
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeObject& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
RTPS_DllAPI bool operator==(
const TypeObject& other) const;
RTPS_DllAPI bool consistent(
const TypeObject& x,
const fastdds::dds::TypeConsistencyEnforcementQosPolicy& consistency) const;
private:
uint8_t m__d;
CompleteTypeObject m_complete;
MinimalTypeObject m_minimal;
};
typedef std::vector<TypeObject> TypeObjectSeq;
// Set of TypeObjects representing a strong component: Equivalence class
// for the Strong Connectivity relationship (mutual reachability between
// types).
// Ordered by fully qualified typename lexicographic order
typedef TypeObjectSeq StronglyConnectedComponent;
/*struct TypeIdentifierTypeObjectPair final {
TypeIdentifier type_identifier;
TypeObject type_object;
};*/
class TypeIdentifierTypeObjectPair final
{
public:
RTPS_DllAPI TypeIdentifierTypeObjectPair();
RTPS_DllAPI ~TypeIdentifierTypeObjectPair();
RTPS_DllAPI TypeIdentifierTypeObjectPair(
const TypeIdentifierTypeObjectPair& x);
RTPS_DllAPI TypeIdentifierTypeObjectPair(
TypeIdentifierTypeObjectPair&& x);
RTPS_DllAPI TypeIdentifierTypeObjectPair& operator=(
const TypeIdentifierTypeObjectPair& x);
RTPS_DllAPI TypeIdentifierTypeObjectPair& operator=(
TypeIdentifierTypeObjectPair&& x);
RTPS_DllAPI inline void type_identifier(
const TypeIdentifier& _type_identifier) { m_type_identifier = _type_identifier; }
RTPS_DllAPI inline void type_identifier(
TypeIdentifier&& _type_identifier) { m_type_identifier = std::move(_type_identifier); }
RTPS_DllAPI inline const TypeIdentifier& type_identifier() const { return m_type_identifier; }
RTPS_DllAPI inline TypeIdentifier& type_identifier() { return m_type_identifier; }
RTPS_DllAPI inline void type_object(
const TypeObject& _type_object) { m_type_object = _type_object; }
RTPS_DllAPI inline void type_object(
TypeObject&& _type_object) { m_type_object = std::move(_type_object); }
RTPS_DllAPI inline const TypeObject& type_object() const { return m_type_object; }
RTPS_DllAPI inline TypeObject& type_object() { return m_type_object; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeIdentifierTypeObjectPair& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
private:
TypeIdentifier m_type_identifier;
TypeObject m_type_object;
};
typedef std::vector<TypeIdentifierTypeObjectPair> TypeIdentifierTypeObjectPairSeq;
/*struct TypeIdentifierPair final {
TypeIdentifier type_identifier1;
TypeIdentifier type_identifier2;
};*/
class TypeIdentifierPair final
{
public:
RTPS_DllAPI TypeIdentifierPair();
RTPS_DllAPI ~TypeIdentifierPair();
RTPS_DllAPI TypeIdentifierPair(
const TypeIdentifierPair& x);
RTPS_DllAPI TypeIdentifierPair(
TypeIdentifierPair&& x);
RTPS_DllAPI TypeIdentifierPair& operator=(
const TypeIdentifierPair& x);
RTPS_DllAPI TypeIdentifierPair& operator=(
TypeIdentifierPair&& x);
RTPS_DllAPI inline void type_identifier1(
const TypeIdentifier& _type_identifier1) { m_type_identifier1 = _type_identifier1; }
RTPS_DllAPI inline void type_identifier1(
TypeIdentifier&& _type_identifier1) { m_type_identifier1 = std::move(_type_identifier1); }
RTPS_DllAPI inline const TypeIdentifier& type_identifier1() const { return m_type_identifier1; }
RTPS_DllAPI inline TypeIdentifier& type_identifier1() { return m_type_identifier1; }
RTPS_DllAPI inline void type_identifier2(
const TypeIdentifier& _type_identifier2) { m_type_identifier2 = _type_identifier2; }
RTPS_DllAPI inline void type_identifier2(
TypeIdentifier&& _type_identifier2) { m_type_identifier2 = std::move(_type_identifier2); }
RTPS_DllAPI inline const TypeIdentifier& type_identifier2() const { return m_type_identifier2; }
RTPS_DllAPI inline TypeIdentifier& type_identifier2() { return m_type_identifier2; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeIdentifierPair& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
private:
TypeIdentifier m_type_identifier1;
TypeIdentifier m_type_identifier2;
};
typedef std::vector<TypeIdentifierPair> TypeIdentifierPairSeq;
/*struct TypeIdentifierWithSize {
TypeIdentifier type_id;
uint32_t typeobject_serialized_size;
};*/
class TypeIdentifierWithSize
{
public:
RTPS_DllAPI TypeIdentifierWithSize();
RTPS_DllAPI ~TypeIdentifierWithSize();
RTPS_DllAPI TypeIdentifierWithSize(
const TypeIdentifierWithSize& x);
RTPS_DllAPI TypeIdentifierWithSize(
TypeIdentifierWithSize&& x);
RTPS_DllAPI TypeIdentifierWithSize& operator=(
const TypeIdentifierWithSize& x);
RTPS_DllAPI TypeIdentifierWithSize& operator=(
TypeIdentifierWithSize&& x);
RTPS_DllAPI inline void type_id(
const TypeIdentifier& _type_id) { m_type_id = _type_id; }
RTPS_DllAPI inline void type_id(
TypeIdentifier&& _type_id) { m_type_id = std::move(_type_id); }
RTPS_DllAPI inline const TypeIdentifier& type_id() const { return m_type_id; }
RTPS_DllAPI inline TypeIdentifier& type_id() { return m_type_id; }
RTPS_DllAPI inline void typeobject_serialized_size(
const uint32_t& _typeobject_serialized_size) { m_typeobject_serialized_size = _typeobject_serialized_size; }
RTPS_DllAPI inline void typeobject_serialized_size(
uint32_t&& _typeobject_serialized_size) {
m_typeobject_serialized_size = std::move(_typeobject_serialized_size);
}
RTPS_DllAPI inline const uint32_t& typeobject_serialized_size() const { return m_typeobject_serialized_size; }
RTPS_DllAPI inline uint32_t& typeobject_serialized_size() { return m_typeobject_serialized_size; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeIdentifierWithSize& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
private:
TypeIdentifier m_type_id;
uint32_t m_typeobject_serialized_size;
};
typedef std::vector<TypeIdentifierWithSize> TypeIdentifierWithSizeSeq;
/*struct TypeIdentifierWithDependencies {
TypeIdentifierWithSize typeid_with_size;
// The total additional types related to minimal_type
int32_t dependent_typeid_count;
TypeIdentifierWithSizeSeq dependent_typeids;
};*/
class TypeIdentifierWithDependencies
{
public:
RTPS_DllAPI TypeIdentifierWithDependencies();
RTPS_DllAPI ~TypeIdentifierWithDependencies();
RTPS_DllAPI TypeIdentifierWithDependencies(
const TypeIdentifierWithDependencies& x);
RTPS_DllAPI TypeIdentifierWithDependencies(
TypeIdentifierWithDependencies&& x);
RTPS_DllAPI TypeIdentifierWithDependencies& operator=(
const TypeIdentifierWithDependencies& x);
RTPS_DllAPI TypeIdentifierWithDependencies& operator=(
TypeIdentifierWithDependencies&& x);
RTPS_DllAPI inline void typeid_with_size(
const TypeIdentifierWithSize& _typeid_with_size) { m_typeid_with_size = _typeid_with_size; }
RTPS_DllAPI inline void typeid_with_size(
TypeIdentifierWithSize&& _typeid_with_size) { m_typeid_with_size = std::move(_typeid_with_size); }
RTPS_DllAPI inline const TypeIdentifierWithSize& typeid_with_size() const { return m_typeid_with_size; }
RTPS_DllAPI inline TypeIdentifierWithSize& typeid_with_size() { return m_typeid_with_size; }
RTPS_DllAPI inline void dependent_typeid_count(
const int32_t& _dependent_typeid_count) { m_dependent_typeid_count = _dependent_typeid_count; }
RTPS_DllAPI inline void dependent_typeid_count(
int32_t&& _dependent_typeid_count) { m_dependent_typeid_count = std::move(_dependent_typeid_count); }
RTPS_DllAPI inline const int32_t& dependent_typeid_count() const { return m_dependent_typeid_count; }
RTPS_DllAPI inline int32_t& dependent_typeid_count() { return m_dependent_typeid_count; }
RTPS_DllAPI inline void dependent_typeids(
const TypeIdentifierWithSizeSeq& _dependent_typeids) { m_dependent_typeids = _dependent_typeids; }
RTPS_DllAPI inline void dependent_typeids(
TypeIdentifierWithSizeSeq&& _dependent_typeids) { m_dependent_typeids = std::move(_dependent_typeids); }
RTPS_DllAPI inline const TypeIdentifierWithSizeSeq& dependent_typeids() const { return m_dependent_typeids; }
RTPS_DllAPI inline TypeIdentifierWithSizeSeq& dependent_typeids() { return m_dependent_typeids; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeIdentifierWithDependencies& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
private:
TypeIdentifierWithSize m_typeid_with_size;
int32_t m_dependent_typeid_count;
TypeIdentifierWithSizeSeq m_dependent_typeids;
};
typedef std::vector<TypeIdentifierWithDependencies> TypeIdentifierWithDependenciesSeq;
// This appears in the builtin DDS topics PublicationBuiltinTopicData
// and SubscriptionBuiltinTopicData
/*struct TypeInformation {
TypeIdentifierWithDependencies minimal; // @id{0x1001}
TypeIdentifierWithDependencies complete; // @id{0x1002}
};*/
class TypeInformation
{
public:
RTPS_DllAPI TypeInformation();
RTPS_DllAPI ~TypeInformation();
RTPS_DllAPI TypeInformation(
const TypeInformation& x);
RTPS_DllAPI TypeInformation(
TypeInformation&& x);
RTPS_DllAPI TypeInformation& operator=(
const TypeInformation& x);
RTPS_DllAPI TypeInformation& operator=(
TypeInformation&& x);
RTPS_DllAPI inline void minimal(
const TypeIdentifierWithDependencies& _minimal) { m_minimal = _minimal; }
RTPS_DllAPI inline void minimal(
TypeIdentifierWithDependencies&& _minimal) { m_minimal = std::move(_minimal); }
RTPS_DllAPI inline const TypeIdentifierWithDependencies& minimal() const { return m_minimal; }
RTPS_DllAPI inline TypeIdentifierWithDependencies& minimal() { return m_minimal; }
RTPS_DllAPI inline void complete(
const TypeIdentifierWithDependencies& _complete) { m_complete = _complete; }
RTPS_DllAPI inline void complete(
TypeIdentifierWithDependencies&& _complete) { m_complete = std::move(_complete); }
RTPS_DllAPI inline const TypeIdentifierWithDependencies& complete() const { return m_complete; }
RTPS_DllAPI inline TypeIdentifierWithDependencies& complete() { return m_complete; }
RTPS_DllAPI static size_t getCdrSerializedSize(
const TypeInformation& data,
size_t current_alignment = 0);
RTPS_DllAPI void serialize(
eprosima::fastcdr::Cdr& cdr) const;
RTPS_DllAPI void deserialize(
eprosima::fastcdr::Cdr& cdr);
private:
TypeIdentifierWithDependencies m_minimal;
TypeIdentifierWithDependencies m_complete;
};
typedef std::vector<TypeInformation> TypeInformationSeq;
} // namespace types
} // namespace fastrtps
} // namespace eprosima
#endif // TYPES_TYPE_OBJECT_H