Classes
class	AnnotationParameterValue

struct	AppliedAnnotation

struct	AppliedAnnotationParameter

struct	AppliedBuiltinMemberAnnotations

struct	AppliedBuiltinTypeAnnotations

struct	AppliedVerbatimAnnotation

struct	CommonAliasBody

struct	CommonAnnotationParameter

struct	CommonArrayHeader

struct	CommonBitfield

struct	CommonBitflag

struct	CommonCollectionElement

struct	CommonCollectionHeader

struct	CommonDiscriminatorMember

struct	CommonEnumeratedHeader

struct	CommonEnumeratedLiteral

struct	CommonStructMember

struct	CommonUnionMember

struct	CompleteAliasBody

struct	CompleteAliasHeader

struct	CompleteAliasType

struct	CompleteAnnotationHeader

struct	CompleteAnnotationParameter

struct	CompleteAnnotationType

struct	CompleteArrayHeader

struct	CompleteArrayType

struct	CompleteBitfield

struct	CompleteBitflag

struct	CompleteBitmaskType

struct	CompleteBitsetHeader

struct	CompleteBitsetType

struct	CompleteCollectionElement

struct	CompleteCollectionHeader

struct	CompleteDiscriminatorMember

struct	CompleteElementDetail

struct	CompleteEnumeratedHeader

struct	CompleteEnumeratedLiteral

struct	CompleteEnumeratedType

struct	CompleteExtendedType

struct	CompleteMapType

struct	CompleteMemberDetail

struct	CompleteSequenceType

struct	CompleteStructHeader

struct	CompleteStructMember

struct	CompleteStructType

struct	CompleteTypeDetail

struct	CompleteTypeObject

struct	CompleteUnionHeader

struct	CompleteUnionMember

struct	CompleteUnionType

class	DynamicDataAdapter

class	DynamicDataAdapter_T

class	DynamicDataAdapterImpl

class	DynamicDataBase

class	DynamicDataImpl

class	DynamicDataReaderImpl

class	DynamicDataWriterImpl

class	DynamicDataXcdrReadImpl

class	DynamicSample

struct	DynamicSequenceAdapter

class	DynamicTypeImpl

class	DynamicTypeMemberImpl

class	DynamicTypeMembersByIdImpl

class	DynamicTypeMembersByNameImpl

struct	EquivalenceHash_tag

struct	EquivalenceHashWrapper

struct	ExtendedAnnotationParameterValue

struct	ExtendedTypeDefn

class	External

class	Fake_TAO_Array_Forany_T

class	MemberDescriptorImpl

class	MemberPath

class	MemberPathParser

struct	MinimalAliasBody

struct	MinimalAliasHeader

struct	MinimalAliasType

struct	MinimalAnnotationHeader

struct	MinimalAnnotationParameter

struct	MinimalAnnotationType

struct	MinimalArrayHeader

struct	MinimalArrayType

struct	MinimalBitfield

struct	MinimalBitflag

struct	MinimalBitmaskType

struct	MinimalBitsetHeader

struct	MinimalBitsetType

struct	MinimalCollectionElement

struct	MinimalCollectionHeader

struct	MinimalDiscriminatorMember

struct	MinimalEnumeratedHeader

struct	MinimalEnumeratedLiteral

struct	MinimalEnumeratedType

struct	MinimalExtendedType

struct	MinimalMapType

struct	MinimalMemberDetail

struct	MinimalSequenceType

struct	MinimalStructHeader

struct	MinimalStructMember

struct	MinimalStructType

struct	MinimalTypeDetail

struct	MinimalTypeObject

struct	MinimalUnionHeader

struct	MinimalUnionMember

struct	MinimalUnionType

struct	NameHash_tag

class	Optional

struct	PlainArrayLElemDefn

struct	PlainArraySElemDefn

struct	PlainCollectionHeader

struct	PlainMapLTypeDefn

struct	PlainMapSTypeDefn

struct	PlainSequenceLElemDefn

struct	PlainSequenceSElemDefn

struct	Sequence

struct	StringLTypeDefn

struct	StringSTypeDefn

struct	StronglyConnectedComponentId

class	TypeAssignability

struct	TypeConsistencyAttributes

class	TypeDescriptorImpl

union	TypeIdentifier

struct	TypeIdentifierPair

struct	TypeIdentifierTypeObjectPair

struct	TypeIdentifierWithDependencies

struct	TypeIdentifierWithSize

struct	TypeInformation

union	TypeLookup_Call

union	TypeLookup_getTypeDependencies_Result

union	TypeLookup_getTypes_Result

struct	TypeLookup_Reply

struct	TypeLookup_Request

union	TypeLookup_Return

class	TypeLookupService

struct	TypeMapBuilder

union	TypeObject

struct	TypeObjectHashId

Typedefs
typedef sequence< octet, 32 >	OctetSeq32

typedef std::pair< const DDS::DynamicType , const DDS::DynamicType >	DynamicTypePtrPair

typedef std::pair< const MinimalStructMember , const MinimalStructMember >	MemberPair

typedef DCPS::RcHandle< TypeLookupService >	TypeLookupService_rch

typedef ACE_CDR::Octet	EquivalenceKind

typedef ACE_CDR::Octet	TypeKind

typedef ACE_CDR::Octet	TypeIdentifierKind

typedef OPENDDS_STRING	MemberName

typedef OPENDDS_STRING	QualifiedTypeName

typedef ACE_CDR::Octet	PrimitiveTypeId

typedef ACE_CDR::Octet	EquivalenceHash[14]

typedef ACE_CDR::Octet	EquivalenceHash_slice

typedef Fake_TAO_Array_Forany_T< EquivalenceHash, EquivalenceHash_slice, EquivalenceHash_tag >	EquivalenceHash_forany

typedef ACE_CDR::Octet	NameHash[4]

typedef ACE_CDR::Octet	NameHash_slice

typedef Fake_TAO_Array_Forany_T< NameHash, NameHash_slice, NameHash_tag >	NameHash_forany

typedef ACE_CDR::ULong	LBound

typedef Sequence< LBound >	LBoundSeq

typedef ACE_CDR::Octet	SBound

typedef Sequence< SBound >	SBoundSeq

typedef ACE_CDR::UShort	MemberFlag

typedef MemberFlag	CollectionElementFlag

typedef MemberFlag	StructMemberFlag

typedef MemberFlag	UnionMemberFlag

typedef MemberFlag	UnionDiscriminatorFlag

typedef MemberFlag	EnumeratedLiteralFlag

typedef MemberFlag	AnnotationParameterFlag

typedef MemberFlag	AliasMemberFlag

typedef MemberFlag	BitflagFlag

typedef MemberFlag	BitsetMemberFlag

typedef ACE_CDR::UShort	TypeFlag

typedef TypeFlag	StructTypeFlag

typedef TypeFlag	UnionTypeFlag

typedef TypeFlag	CollectionTypeFlag

typedef TypeFlag	AnnotationTypeFlag

typedef TypeFlag	AliasTypeFlag

typedef TypeFlag	EnumTypeFlag

typedef TypeFlag	BitmaskTypeFlag

typedef TypeFlag	BitsetTypeFlag

typedef Sequence< TypeIdentifier >	TypeIdentifierSeq

typedef ACE_CDR::ULong	MemberId

typedef Sequence< AppliedAnnotationParameter >	AppliedAnnotationParameterSeq

typedef Sequence< AppliedAnnotation >	AppliedAnnotationSeq

typedef Sequence< CompleteStructMember >	CompleteStructMemberSeq

typedef Sequence< MinimalStructMember >	MinimalStructMemberSeq

typedef Sequence< ACE_CDR::Long >	UnionCaseLabelSeq

typedef Sequence< CompleteUnionMember >	CompleteUnionMemberSeq

typedef Sequence< MinimalUnionMember >	MinimalUnionMemberSeq

typedef Sequence< CompleteAnnotationParameter >	CompleteAnnotationParameterSeq

typedef Sequence< MinimalAnnotationParameter >	MinimalAnnotationParameterSeq

typedef ACE_CDR::UShort	BitBound

typedef Sequence< CompleteEnumeratedLiteral >	CompleteEnumeratedLiteralSeq

typedef Sequence< MinimalEnumeratedLiteral >	MinimalEnumeratedLiteralSeq

typedef Sequence< CompleteBitflag >	CompleteBitflagSeq

typedef Sequence< MinimalBitflag >	MinimalBitflagSeq

typedef CompleteEnumeratedHeader	CompleteBitmaskHeader

typedef MinimalEnumeratedHeader	MinimalBitmaskHeader

typedef Sequence< CompleteBitfield >	CompleteBitfieldSeq

typedef Sequence< MinimalBitfield >	MinimalBitfieldSeq

typedef Sequence< TypeObject >	TypeObjectSeq

typedef TypeObjectSeq	StronglyConnectedComponent

typedef Sequence< TypeIdentifierTypeObjectPair >	TypeIdentifierTypeObjectPairSeq

typedef Sequence< TypeIdentifierPair >	TypeIdentifierPairSeq

typedef Sequence< TypeIdentifierWithSize >	TypeIdentifierWithSizeSeq

typedef Sequence< TypeIdentifierWithDependencies >	TypeIdentifierWithDependenciesSeq

Enumerations
enum	Filter { Filter_All, Filter_Keys, Filter_NestedKeys, Filter_NonKeys }

Functions
	extensibility (MUTABLE) struct TypeLookup_getTypes_In

template<typename T , typename Tag >
DDS::DynamicData_ptr	get_dynamic_data_adapter (DDS::DynamicType_ptr type, const T &value)

template<typename T , typename Tag >
DDS::DynamicData_ptr	get_dynamic_data_adapter (DDS::DynamicType_ptr type, T &value)

template<typename T >
DDS::DynamicData_ptr	get_dynamic_data_adapter (DDS::DynamicType_ptr type, T &value)

template<typename T >
DDS::DynamicData_ptr	get_dynamic_data_adapter (DDS::DynamicType_ptr type, const T &value)

template<typename T , typename Tag >
const T *	get_dynamic_data_adapter_value (DDS::DynamicData_ptr dda)

template<>
bool	DynamicDataImpl::get_boolean_from_bitmask< CORBA::UInt8 > (CORBA::ULong index, CORBA::Boolean &value)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::StringSeq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::Int8Seq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::UInt8Seq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::CharSeq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::ByteSeq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

template<>
void	DynamicDataImpl::move_sequence_helper< DDS::BooleanSeq > (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

bool	print_member (DDS::DynamicData_ptr dd, DCPS::String &type_string, DCPS::String &indent, MemberId member_id)

bool	print_members (DDS::DynamicData_ptr dd, DCPS::String &type_string, DCPS::String &indent, bool print_name)

bool	print_dynamic_data (DDS::DynamicData_ptr dd, DCPS::String &type_string, DCPS::String &indent)

DDS::DynamicType_var	get_base_type (DDS::DynamicType_ptr type)

bool	test_equality (DDS::DynamicType_ptr lhs, DDS::DynamicType_ptr rhs, DynamicTypePtrPairSeen &dt_ptr_pair)

bool	test_equality (DynamicTypeMembersByNameImpl lhs, DynamicTypeMembersByNameImpl rhs, DynamicTypePtrPairSeen &dt_ptr_pair)

bool	test_equality (DynamicTypeMembersByIdImpl lhs, DynamicTypeMembersByIdImpl rhs, DynamicTypePtrPairSeen &dt_ptr_pair)

template<>
DDS::DynamicData_ptr	get_dynamic_data_adapter< DynamicSample, DynamicSample > (DDS::DynamicType_ptr, const DynamicSample &value)

template<>
DDS::DynamicData_ptr	get_dynamic_data_adapter< DynamicSample, DynamicSample > (DDS::DynamicType_ptr, DynamicSample &value)

bool	operator== (const DDS::UnionCaseLabelSeq &lhs, const DDS::UnionCaseLabelSeq &rhs)

bool	test_equality (DDS::MemberDescriptor lhs, DDS::MemberDescriptor rhs, DynamicTypePtrPairSeen &dt_ptr_pair)

typedef	OPENDDS_SET (DynamicTypePtrPair) DynamicTypePtrPairSeen

typedef	OPENDDS_VECTOR (MemberPair) MatchedSet

bool	operator== (const DDS::BoundSeq &lhs, const DDS::BoundSeq &rhs)

bool	test_equality (DDS::TypeDescriptor lhs, DDS::TypeDescriptor rhs, DynamicTypePtrPairSeen &dt_ptr_pair)

const Encoding &	get_typeobject_encoding ()

DCPS::String	equivalence_hash_to_string (const EquivalenceHash &equivalence_hash)

TypeIdentifier	makeTypeIdentifier (const TypeObject &type_object, const DCPS::Encoding *encoding_option)

ACE_CDR::ULong	hash_member_name_to_id (const OPENDDS_STRING &name)

void	hash_member_name (NameHash &name_hash, const OPENDDS_STRING &name)

bool	is_fully_descriptive (const TypeIdentifier &ti)

bool	is_plain_collection (const TypeIdentifier &ti)

bool	has_type_object (const TypeIdentifier &ti)

void	compute_dependencies (const TypeMap &type_map, const TypeIdentifier &type_identifier, OPENDDS_SET(TypeIdentifier)&dependencies)

bool	write_empty_xcdr2_nonfinal (DCPS::Serializer &strm)

bool	read_empty_xcdr2_nonfinal (DCPS::Serializer &strm)

const char *	typekind_to_string (TypeKind tk)

bool	is_primitive (TypeKind tk)

bool	is_scalar (TypeKind tk)

bool	is_basic (TypeKind tk)

bool	is_complex (TypeKind tk)

bool	is_sequence_like (TypeKind tk)

bool	name_hash_equal (const NameHash &x, const NameHash &y)

bool	name_hash_not_equal (const NameHash &x, const NameHash &y)

template<typename T >
void	serialize_type_info (const TypeInformation &type_info, T &seq, const DCPS::Encoding *encoding_option=0)

template<typename T >
bool	deserialize_type_info (TypeInformation &type_info, const T &seq)

typedef	OPENDDS_MAP (TypeIdentifier, TypeObject) TypeMap

DDS::ReturnCode_t	extensibility (DDS::DynamicType_ptr type, DCPS::Extensibility &ext)

DDS::ReturnCode_t	max_extensibility (DDS::DynamicType_ptr type, DCPS::Extensibility &ext)

DCPS::Extensibility	dds_to_opendds_ext (DDS::ExtensibilityKind ext)

DDS::ReturnCode_t	get_values (DDS::DynamicType_ptr type, MemberPathVec &paths, Filter filter)

DDS::ReturnCode_t	get_keys (DDS::DynamicType_ptr type, MemberPathVec &paths)

DDS::ReturnCode_t	key_count (DDS::DynamicType_ptr type, size_t &count)

bool	is_key (DDS::DynamicType_ptr type, const char *field)

DDS::ReturnCode_t	less_than (bool &result, DDS::DynamicData_ptr a, DDS::DynamicData_ptr b, Filter filter)

DDS::ReturnCode_t	key_less_than (bool &result, DDS::DynamicData_ptr a, DDS::DynamicData_ptr b)

DDS::ReturnCode_t	compare_members (int &result, DDS::DynamicData_ptr a, DDS::DynamicData_ptr b, DDS::MemberId id)

DDS::ReturnCode_t	get_member_type (DDS::DynamicType_var &member_type, DDS::DynamicType_ptr container_type, DDS::MemberId id)

DDS::ReturnCode_t	get_uint_value (DDS::UInt64 &value, DDS::DynamicData_ptr src, DDS::MemberId id, DDS::TypeKind kind)

DDS::ReturnCode_t	set_uint_value (DDS::DynamicData_ptr dest, DDS::MemberId id, DDS::TypeKind kind, DDS::UInt64 value)

DDS::ReturnCode_t	get_int_value (DDS::Int64 &value, DDS::DynamicData_ptr src, DDS::MemberId id, DDS::TypeKind kind)

DDS::ReturnCode_t	set_int_value (DDS::DynamicData_ptr dest, DDS::MemberId id, DDS::TypeKind kind, DDS::Int64 value)

DDS::UInt32	bound_total (DDS::TypeDescriptor_var descriptor)

DDS::ReturnCode_t	bitmask_bound (DDS::DynamicType_ptr type, DDS::TypeKind &bound_kind)

DDS::ReturnCode_t	get_bitmask_value (DDS::UInt64 &value, DDS::DynamicType_ptr type, DDS::DynamicData_ptr src, DDS::MemberId id)

DDS::ReturnCode_t	enum_bound (DDS::DynamicType_ptr enum_type, DDS::TypeKind &bound_kind)

DDS::ReturnCode_t	get_enum_value (DDS::Int32 &value, DDS::DynamicType_ptr enum_type, DDS::DynamicData_ptr src, DDS::MemberId id)

DDS::ReturnCode_t	get_enumerator_name (DDS::String8_var &name, DDS::Int32 value, DDS::DynamicType_ptr type)

DDS::ReturnCode_t	get_enumerator_value (DDS::Int32 &value, const char *name, DDS::DynamicType_ptr type)

DDS::ReturnCode_t	set_enum_value (DDS::DynamicType_ptr enum_type, DDS::DynamicData_ptr dest, DDS::MemberId id, DDS::Int32 value)

DDS::ReturnCode_t	set_enum_value (DDS::DynamicType_ptr type, DDS::DynamicData_ptr dest, DDS::MemberId id, const char *enumeral_name)

DDS::ReturnCode_t	copy_member (DDS::DynamicData_ptr dest, DDS::MemberId dest_id, DDS::DynamicData_ptr src, DDS::MemberId src_id)

DDS::ReturnCode_t	copy (DDS::DynamicData_ptr dest, DDS::DynamicData_ptr src)

bool	dynamic_type_is_valid (DDS::DynamicType_ptr type)

typedef	OPENDDS_VECTOR (MemberPath) MemberPathVec

DDS::ReturnCode_t	get_member_type (DDS::DynamicType_var &member_type, DDS::DynamicData_ptr container, DDS::MemberId id)

DDS::ReturnCode_t	get_enum_value (DDS::Int32 &value, DDS::DynamicData_ptr src, DDS::MemberId id)

DDS::ReturnCode_t	set_enum_value (DDS::DynamicData_ptr dest, DDS::MemberId id, DDS::Int32 value)

DDS::ReturnCode_t	set_enum_value (DDS::DynamicData_ptr dest, DDS::MemberId id, const char *enumeral_name)

Variables
const long	DDS_RETCODE_OK = 0

const long	TypeLookup_getTypes_HashId = 0x018252d3

const long	TypeLookup_getDependencies_HashId = 0x05aafb31

const EquivalenceKind	EK_MINIMAL = 0xF1

const EquivalenceKind	EK_COMPLETE = 0xF2

const EquivalenceKind	EK_BOTH = 0xF3

const TypeKind	TK_NONE = 0x00

const TypeKind	TK_BOOLEAN = 0x01

const TypeKind	TK_BYTE = 0x02

const TypeKind	TK_INT16 = 0x03

const TypeKind	TK_INT32 = 0x04

const TypeKind	TK_INT64 = 0x05

const TypeKind	TK_UINT16 = 0x06

const TypeKind	TK_UINT32 = 0x07

const TypeKind	TK_UINT64 = 0x08

const TypeKind	TK_FLOAT32 = 0x09

const TypeKind	TK_FLOAT64 = 0x0A

const TypeKind	TK_FLOAT128 = 0x0B

const TypeKind	TK_INT8 = 0x0C

const TypeKind	TK_UINT8 = 0x0D

const TypeKind	TK_CHAR8 = 0x10

const TypeKind	TK_CHAR16 = 0x11

const TypeKind	TK_STRING8 = 0x20

const TypeKind	TK_STRING16 = 0x21

const TypeKind	TK_ALIAS = 0x30

const TypeKind	TK_ENUM = 0x40

const TypeKind	TK_BITMASK = 0x41

const TypeKind	TK_ANNOTATION = 0x50

const TypeKind	TK_STRUCTURE = 0x51

const TypeKind	TK_UNION = 0x52

const TypeKind	TK_BITSET = 0x53

const TypeKind	TK_SEQUENCE = 0x60

const TypeKind	TK_ARRAY = 0x61

const TypeKind	TK_MAP = 0x62

const TypeIdentifierKind	TI_STRING8_SMALL = 0x70

const TypeIdentifierKind	TI_STRING8_LARGE = 0x71

const TypeIdentifierKind	TI_STRING16_SMALL = 0x72

const TypeIdentifierKind	TI_STRING16_LARGE = 0x73

const TypeIdentifierKind	TI_PLAIN_SEQUENCE_SMALL = 0x80

const TypeIdentifierKind	TI_PLAIN_SEQUENCE_LARGE = 0x81

const TypeIdentifierKind	TI_PLAIN_ARRAY_SMALL = 0x90

const TypeIdentifierKind	TI_PLAIN_ARRAY_LARGE = 0x91

const TypeIdentifierKind	TI_PLAIN_MAP_SMALL = 0xA0

const TypeIdentifierKind	TI_PLAIN_MAP_LARGE = 0xA1

const TypeIdentifierKind	TI_STRONGLY_CONNECTED_COMPONENT = 0xB0

const ACE_CDR::Long	MEMBER_NAME_MAX_LENGTH = 256

const ACE_CDR::Long	TYPE_NAME_MAX_LENGTH = 256

const LBound	INVALID_LBOUND = 0

const SBound	INVALID_SBOUND = 0

const MemberFlag	TRY_CONSTRUCT1 = 1 << 0

const MemberFlag	TRY_CONSTRUCT2 = 1 << 1

const MemberFlag	IS_EXTERNAL = 1 << 2

const MemberFlag	IS_OPTIONAL = 1 << 3

const MemberFlag	IS_MUST_UNDERSTAND = 1 << 4

const MemberFlag	IS_KEY = 1 << 5

const MemberFlag	IS_DEFAULT = 1 << 6

const MemberFlag	TryConstructDiscardValue = TRY_CONSTRUCT1

const MemberFlag	TryConstructUseDefaultValue = TRY_CONSTRUCT2

const MemberFlag	TryConstructTrimValue = TRY_CONSTRUCT1 \| TRY_CONSTRUCT2

const MemberFlag	MemberFlagMinimalMask = 0x003f

const TypeFlag	IS_FINAL = 1 << 0

const TypeFlag	IS_APPENDABLE = 1 << 1

const TypeFlag	IS_MUTABLE = 1 << 2

const TypeFlag	IS_NESTED = 1 << 3

const TypeFlag	IS_AUTOID_HASH = 1 << 4

const TypeFlag	TypeFlagMinimalMask = 0x0007

const ACE_CDR::ULong	MEMBER_ID_INVALID = ACE_UINT32_MAX

const ACE_CDR::ULong	DISCRIMINATOR_ID = MEMBER_ID_INVALID - 1
	Implementation specific sentinel for a union discriminator used in DynamicData. More...

const ACE_CDR::ULong	ANNOTATION_STR_VALUE_MAX_LEN = 128

const ACE_CDR::ULong	ANNOTATION_OCTETSEC_VALUE_MAX_LEN = 128

Typedef Documentation

◆ AliasMemberFlag

typedef MemberFlag OpenDDS::XTypes::AliasMemberFlag

Definition at line 384 of file TypeObject.h.

◆ AliasTypeFlag

typedef TypeFlag OpenDDS::XTypes::AliasTypeFlag

Definition at line 411 of file TypeObject.h.

◆ AnnotationParameterFlag

typedef MemberFlag OpenDDS::XTypes::AnnotationParameterFlag

Definition at line 383 of file TypeObject.h.

◆ AnnotationTypeFlag

typedef TypeFlag OpenDDS::XTypes::AnnotationTypeFlag

Definition at line 410 of file TypeObject.h.

◆ AppliedAnnotationParameterSeq

typedef Sequence<AppliedAnnotationParameter> OpenDDS::XTypes::AppliedAnnotationParameterSeq

Definition at line 1135 of file TypeObject.h.

◆ AppliedAnnotationSeq

typedef Sequence<AppliedAnnotation> OpenDDS::XTypes::AppliedAnnotationSeq

Definition at line 1165 of file TypeObject.h.

◆ BitBound

typedef ACE_CDR::UShort OpenDDS::XTypes::BitBound

Definition at line 2478 of file TypeObject.h.

◆ BitflagFlag

typedef MemberFlag OpenDDS::XTypes::BitflagFlag

Definition at line 385 of file TypeObject.h.

◆ BitmaskTypeFlag

typedef TypeFlag OpenDDS::XTypes::BitmaskTypeFlag

Definition at line 413 of file TypeObject.h.

◆ BitsetMemberFlag

typedef MemberFlag OpenDDS::XTypes::BitsetMemberFlag

Definition at line 386 of file TypeObject.h.

◆ BitsetTypeFlag

typedef TypeFlag OpenDDS::XTypes::BitsetTypeFlag

Definition at line 414 of file TypeObject.h.

◆ CollectionElementFlag

typedef MemberFlag OpenDDS::XTypes::CollectionElementFlag

Definition at line 378 of file TypeObject.h.

◆ CollectionTypeFlag

typedef TypeFlag OpenDDS::XTypes::CollectionTypeFlag

Definition at line 409 of file TypeObject.h.

◆ CompleteAnnotationParameterSeq

typedef Sequence<CompleteAnnotationParameter> OpenDDS::XTypes::CompleteAnnotationParameterSeq

Definition at line 1842 of file TypeObject.h.

◆ CompleteBitfieldSeq

typedef Sequence<CompleteBitfield> OpenDDS::XTypes::CompleteBitfieldSeq

Definition at line 2837 of file TypeObject.h.

◆ CompleteBitflagSeq

typedef Sequence<CompleteBitflag> OpenDDS::XTypes::CompleteBitflagSeq

Definition at line 2729 of file TypeObject.h.

◆ CompleteBitmaskHeader

typedef CompleteEnumeratedHeader OpenDDS::XTypes::CompleteBitmaskHeader

Definition at line 2753 of file TypeObject.h.

◆ CompleteEnumeratedLiteralSeq

typedef Sequence<CompleteEnumeratedLiteral> OpenDDS::XTypes::CompleteEnumeratedLiteralSeq

Definition at line 2536 of file TypeObject.h.

◆ CompleteStructMemberSeq

typedef Sequence<CompleteStructMember> OpenDDS::XTypes::CompleteStructMemberSeq

Definition at line 1336 of file TypeObject.h.

◆ CompleteUnionMemberSeq

typedef Sequence<CompleteUnionMember> OpenDDS::XTypes::CompleteUnionMemberSeq

Definition at line 1597 of file TypeObject.h.

◆ DynamicTypePtrPair

typedef std::pair< const DDS::DynamicType *, const DDS::DynamicType * > OpenDDS::XTypes::DynamicTypePtrPair

Definition at line 48 of file MemberDescriptorImpl.h.

◆ EnumeratedLiteralFlag

typedef MemberFlag OpenDDS::XTypes::EnumeratedLiteralFlag

Definition at line 382 of file TypeObject.h.

◆ EnumTypeFlag

typedef TypeFlag OpenDDS::XTypes::EnumTypeFlag

Definition at line 412 of file TypeObject.h.

◆ EquivalenceHash

typedef ACE_CDR::Octet OpenDDS::XTypes::EquivalenceHash[14]

Definition at line 287 of file TypeObject.h.

◆ EquivalenceHash_forany

typedef Fake_TAO_Array_Forany_T<EquivalenceHash, EquivalenceHash_slice, EquivalenceHash_tag> OpenDDS::XTypes::EquivalenceHash_forany

Definition at line 290 of file TypeObject.h.

◆ EquivalenceHash_slice

typedef ACE_CDR::Octet OpenDDS::XTypes::EquivalenceHash_slice

Definition at line 289 of file TypeObject.h.

◆ EquivalenceKind

typedef short OpenDDS::XTypes::EquivalenceKind

Definition at line 204 of file TypeObject.h.

◆ LBound

typedef ACE_CDR::ULong OpenDDS::XTypes::LBound

Definition at line 312 of file TypeObject.h.

◆ LBoundSeq

typedef Sequence<LBound> OpenDDS::XTypes::LBoundSeq

Definition at line 313 of file TypeObject.h.

◆ MemberFlag

typedef ACE_CDR::UShort OpenDDS::XTypes::MemberFlag

Definition at line 368 of file TypeObject.h.

◆ MemberId

typedef ACE_CDR::ULong OpenDDS::XTypes::MemberId

Definition at line 910 of file TypeObject.h.

◆ MemberName

typedef OPENDDS_STRING OpenDDS::XTypes::MemberName

Definition at line 275 of file TypeObject.h.

◆ MemberPair

typedef std::pair<const MinimalStructMember*, const MinimalStructMember*> OpenDDS::XTypes::MemberPair

Definition at line 24 of file TypeAssignability.h.

◆ MinimalAnnotationParameterSeq

typedef Sequence<MinimalAnnotationParameter> OpenDDS::XTypes::MinimalAnnotationParameterSeq

Definition at line 1865 of file TypeObject.h.

◆ MinimalBitfieldSeq

typedef Sequence<MinimalBitfield> OpenDDS::XTypes::MinimalBitfieldSeq

Definition at line 2859 of file TypeObject.h.

◆ MinimalBitflagSeq

typedef Sequence<MinimalBitflag> OpenDDS::XTypes::MinimalBitflagSeq

Definition at line 2746 of file TypeObject.h.

◆ MinimalBitmaskHeader

typedef MinimalEnumeratedHeader OpenDDS::XTypes::MinimalBitmaskHeader

Definition at line 2755 of file TypeObject.h.

◆ MinimalEnumeratedLiteralSeq

typedef Sequence<MinimalEnumeratedLiteral> OpenDDS::XTypes::MinimalEnumeratedLiteralSeq

Definition at line 2567 of file TypeObject.h.

◆ MinimalStructMemberSeq

typedef Sequence<MinimalStructMember> OpenDDS::XTypes::MinimalStructMemberSeq

Definition at line 1367 of file TypeObject.h.

◆ MinimalUnionMemberSeq

typedef Sequence<MinimalUnionMember> OpenDDS::XTypes::MinimalUnionMemberSeq

Definition at line 1628 of file TypeObject.h.

◆ NameHash

typedef ACE_CDR::Octet OpenDDS::XTypes::NameHash[4]

Definition at line 296 of file TypeObject.h.

◆ NameHash_forany

typedef Fake_TAO_Array_Forany_T<NameHash, NameHash_slice, NameHash_tag> OpenDDS::XTypes::NameHash_forany

Definition at line 299 of file TypeObject.h.

◆ NameHash_slice

typedef ACE_CDR::Octet OpenDDS::XTypes::NameHash_slice

Definition at line 298 of file TypeObject.h.

◆ OctetSeq32

typedef sequence<octet, 32> OpenDDS::XTypes::OctetSeq32

Definition at line 45 of file TypeLookup.idl.

◆ PrimitiveTypeId

typedef ACE_CDR::Octet OpenDDS::XTypes::PrimitiveTypeId

Definition at line 283 of file TypeObject.h.

◆ QualifiedTypeName

typedef OPENDDS_STRING OpenDDS::XTypes::QualifiedTypeName

Definition at line 280 of file TypeObject.h.

◆ SBound

typedef ACE_CDR::Octet OpenDDS::XTypes::SBound

Definition at line 317 of file TypeObject.h.

◆ SBoundSeq

typedef Sequence<SBound> OpenDDS::XTypes::SBoundSeq

Definition at line 318 of file TypeObject.h.

◆ StronglyConnectedComponent

typedef TypeObjectSeq OpenDDS::XTypes::StronglyConnectedComponent

Definition at line 3283 of file TypeObject.h.

◆ StructMemberFlag

typedef MemberFlag OpenDDS::XTypes::StructMemberFlag

Definition at line 379 of file TypeObject.h.

◆ StructTypeFlag

typedef TypeFlag OpenDDS::XTypes::StructTypeFlag

Definition at line 407 of file TypeObject.h.

◆ TypeFlag

typedef ACE_CDR::UShort OpenDDS::XTypes::TypeFlag

Definition at line 399 of file TypeObject.h.

◆ TypeIdentifierKind

typedef ACE_CDR::Octet OpenDDS::XTypes::TypeIdentifierKind

Definition at line 254 of file TypeObject.h.

◆ TypeIdentifierPairSeq

OpenDDS::internal::no_dynamic_data_adapter typedef sequence< TypeIdentifierPair > OpenDDS::XTypes::TypeIdentifierPairSeq

Definition at line 3329 of file TypeObject.h.

◆ TypeIdentifierSeq

OpenDDS::internal::no_dynamic_data_adapter typedef sequence< TypeIdentifier > OpenDDS::XTypes::TypeIdentifierSeq

Definition at line 830 of file TypeObject.h.

◆ TypeIdentifierTypeObjectPairSeq

OpenDDS::internal::no_dynamic_data_adapter typedef sequence< TypeIdentifierTypeObjectPair > OpenDDS::XTypes::TypeIdentifierTypeObjectPairSeq

Definition at line 3306 of file TypeObject.h.

◆ TypeIdentifierWithDependenciesSeq

typedef Sequence<TypeIdentifierWithDependencies> OpenDDS::XTypes::TypeIdentifierWithDependenciesSeq

Definition at line 3367 of file TypeObject.h.

◆ TypeIdentifierWithSizeSeq

OpenDDS::internal::no_dynamic_data_adapter typedef sequence< TypeIdentifierWithSize > OpenDDS::XTypes::TypeIdentifierWithSizeSeq

Definition at line 3354 of file TypeObject.h.

◆ TypeKind

typedef short OpenDDS::XTypes::TypeKind

Definition at line 210 of file TypeObject.h.

◆ TypeLookupService_rch

typedef DCPS::RcHandle<TypeLookupService> OpenDDS::XTypes::TypeLookupService_rch

Definition at line 127 of file TypeLookupService.h.

◆ TypeObjectSeq

typedef Sequence<TypeObject> OpenDDS::XTypes::TypeObjectSeq

Definition at line 3277 of file TypeObject.h.

◆ UnionCaseLabelSeq

typedef Sequence<ACE_CDR::Long> OpenDDS::XTypes::UnionCaseLabelSeq

Definition at line 1534 of file TypeObject.h.

◆ UnionDiscriminatorFlag

typedef MemberFlag OpenDDS::XTypes::UnionDiscriminatorFlag

Definition at line 381 of file TypeObject.h.

◆ UnionMemberFlag

typedef MemberFlag OpenDDS::XTypes::UnionMemberFlag

Definition at line 380 of file TypeObject.h.

◆ UnionTypeFlag

typedef TypeFlag OpenDDS::XTypes::UnionTypeFlag

Definition at line 408 of file TypeObject.h.

Enumeration Type Documentation

◆ Filter

enum OpenDDS::XTypes::Filter

Enumerator
Filter_All
Filter_Keys
Filter_NestedKeys
Filter_NonKeys

Definition at line 125 of file XTypes/Utils.h.

             {
   Filter_All,
   Filter_Keys,
   Filter_NestedKeys,
   Filter_NonKeys
 };

Function Documentation

◆ bitmask_bound()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::bitmask_bound	(	DDS::DynamicType_ptr	type,
		DDS::TypeKind &	bound_kind
	)

Definition at line 1025 of file XTypes/Utils.cpp.

References ACE_ERROR, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_BITMASK, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, and typekind_to_string().

Referenced by OpenDDS::XTypes::DynamicDataBase::check_member(), OpenDDS::XTypes::DynamicDataImpl::clear_value_i(), get_bitmask_value(), get_member_type(), OpenDDS::XTypes::DynamicDataImpl::get_value_from_bitmask(), and OpenDDS::XTypes::DynamicDataImpl::get_value_from_collection().

 {
   const DDS::TypeKind kind = type->get_kind();
   if (kind != TK_BITMASK) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: bitmask_bound: "
         "expected bitmask, got %C\n",
         typekind_to_string(kind)));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
 
   DDS::TypeDescriptor_var td;
   const DDS::ReturnCode_t rc = type->get_descriptor(td);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   const size_t bound_size = td->bound()[0];
   if (bound_size >= 1 && bound_size <= 8) {
     bound_kind = TK_UINT8;
   } else if (bound_size >= 9 && bound_size <= 16) {
     bound_kind = TK_UINT16;
   } else if (bound_size >= 17 && bound_size <= 32) {
     bound_kind = TK_UINT32;
   } else if (bound_size >= 33 && bound_size <= 64) {
     bound_kind = TK_UINT64;
   } else {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: bitmask_bound: "
         "Got unexpected bound size %B\n",
         bound_size));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
   return DDS::RETCODE_OK;
 }

◆ bound_total()

OpenDDS_Dcps_Export DDS::UInt32 OpenDDS::XTypes::bound_total ( DDS::TypeDescriptor_var descriptor )

Definition at line 1015 of file XTypes/Utils.cpp.

 {
   DDS::UInt32 total = 1;
   const DDS::BoundSeq& bounds = descriptor->bound();
   for (DDS::UInt32 i = 0; i < bounds.length(); ++i) {
     total *= bounds[i];
   }
   return total;
 }

◆ compare_members()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::compare_members	(	int &	result,
		DDS::DynamicData_ptr	a,
		DDS::DynamicData_ptr	b,
		DDS::MemberId	id
	)

Definition at line 865 of file XTypes/Utils.cpp.

Referenced by OpenDDS::DCPS::DynamicComparator::cmp().

 {
   return member_compare(result, a, id, b, id);
 }

◆ compute_dependencies()

void OpenDDS::XTypes::compute_dependencies	(	const TypeMap &	type_map,
		const TypeIdentifier &	type_identifier,
		OPENDDS_SET(TypeIdentifier)&	dependencies
	)

Definition at line 1055 of file TypeObject.cpp.

References EK_COMPLETE, EK_MINIMAL, OpenDDS::XTypes::TypeIdentifier::kind(), TI_PLAIN_ARRAY_LARGE, TI_PLAIN_ARRAY_SMALL, TI_PLAIN_MAP_LARGE, TI_PLAIN_MAP_SMALL, TI_PLAIN_SEQUENCE_LARGE, TI_PLAIN_SEQUENCE_SMALL, TI_STRING16_LARGE, TI_STRING16_SMALL, TI_STRING8_LARGE, TI_STRING8_SMALL, and TI_STRONGLY_CONNECTED_COMPONENT.

Referenced by has_type_object(), OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &(), and OpenDDS::DCPS::TypeSupportImpl::populate_dependencies_i().

 {
   if (dependencies.count(type_identifier) != 0) {
     return;
   }
 
   dependencies.insert(type_identifier);
 
   switch (type_identifier.kind()) {
   case TI_STRING8_SMALL:
   case TI_STRING16_SMALL:
     compute_dependencies(type_map, type_identifier.string_sdefn(), dependencies);
     break;
   case TI_STRING8_LARGE:
   case TI_STRING16_LARGE:
     compute_dependencies(type_map, type_identifier.string_ldefn(), dependencies);
     break;
   case TI_PLAIN_SEQUENCE_SMALL:
     compute_dependencies(type_map, type_identifier.seq_sdefn(), dependencies);
     break;
   case TI_PLAIN_SEQUENCE_LARGE:
     compute_dependencies(type_map, type_identifier.seq_ldefn(), dependencies);
     break;
   case TI_PLAIN_ARRAY_SMALL:
     compute_dependencies(type_map, type_identifier.array_sdefn(), dependencies);
     break;
   case TI_PLAIN_ARRAY_LARGE:
     compute_dependencies(type_map, type_identifier.array_ldefn(), dependencies);
     break;
   case TI_PLAIN_MAP_SMALL:
     compute_dependencies(type_map, type_identifier.map_sdefn(), dependencies);
     break;
   case TI_PLAIN_MAP_LARGE:
     compute_dependencies(type_map, type_identifier.map_ldefn(), dependencies);
     break;
   case TI_STRONGLY_CONNECTED_COMPONENT:
     compute_dependencies(type_map, type_identifier.sc_component_id(), dependencies);
     break;
   case EK_COMPLETE:
   case EK_MINIMAL:
     {
       TypeMap::const_iterator pos = type_map.find(type_identifier);
       if (pos != type_map.end()) {
         compute_dependencies(type_map, pos->second, dependencies);
       }
       break;
     }
   }
 }

◆ copy()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::copy	(	DDS::DynamicData_ptr	dest,
		DDS::DynamicData_ptr	src
	)

Definition at line 1454 of file XTypes/Utils.cpp.

References ACE_ERROR, OpenDDS::XTypes::DynamicTypeMembersByIdImpl::begin(), copy_member(), DISCRIMINATOR_ID, OpenDDS::XTypes::DynamicTypeMembersByIdImpl::end(), OpenDDS::XTypes::DynamicTypeMembersByIdImpl::find(), get_base_type(), LM_NOTICE, LM_WARNING, OpenDDS::DCPS::log_level, MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, OPENDDS_END_VERSIONED_NAMESPACE_DECL, DDS::RETCODE_OK, OpenDDS::DCPS::retcode_to_string(), DDS::RETCODE_UNSUPPORTED, TK_ALIAS, TK_ANNOTATION, TK_ARRAY, TK_BITSET, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_ENUM, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_MAP, TK_SEQUENCE, TK_STRING16, TK_STRING8, TK_STRUCTURE, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, TK_UNION, typekind_to_string(), and OpenDDS::DCPS::LogLevel::Warning.

Referenced by OpenDDS::DCPS::BasicQueue< TransportQueueElement >::accept_remove_visitor(), OpenDDS::DCPS::choose_single_coherent_address(), TAO_DDS_DCPSInfo_i::cleanup_all_built_in_topics(), OpenDDS::XTypes::DynamicDataBase::clone(), OpenDDS::DCPS::Sample::copy(), copy_member(), OpenDDS::SafetyProfile::VariEltPolicy< T >::copy_n(), OpenDDS::SafetyProfile::ArrayEltPolicy< Forany, T >::copy_n(), OpenDDS::DCPS::DataSampleElement::DataSampleElement(), OpenDDS::DCPS::DomainParticipantFactoryImpl::delete_all_participants(), OpenDDS::DCPS::DataWriterImpl::get_or_create_instance_handle(), OpenDDS::DCPS::TransportReassembly::FragInfo::insert(), OpenDDS::DCPS::DisjointSequence::insert_filtered(), OpenDDS::DCPS::Sample::key_only(), TAO::DCPS::ZeroCopyDataSeq< Sample_T, DEF_MAX >::length(), OpenDDS::DCPS::MessageBlock::operator=(), OpenDDS::DCPS::DataSampleElement::operator=(), set_enum_value(), OpenDDS::XTypes::DynamicDataAdapter::set_indirect_complex_raw_value_impl(), OpenDDS::Security::SSL::Certificate::subject_name_to_str(), and OpenDDS::DCPS::TransportHeader::TransportHeader().

 {
   if (dest == src) {
     return DDS::RETCODE_OK;
   }
 
   const DDS::DynamicType_var dest_type = dest->type();
   const DDS::DynamicType_var actual_dest_type = get_base_type(dest_type);
   const DDS::TypeKind dest_tk = actual_dest_type->get_kind();
 
   const DDS::DynamicType_var src_type = src->type();
   const DDS::DynamicType_var actual_src_type = get_base_type(src_type);
   const DDS::TypeKind src_tk = actual_src_type->get_kind();
 
   if (src_tk != dest_tk) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: copy(DynamicData): "
         "Can not copy type %C to type %C\n",
         typekind_to_string(src_tk), typekind_to_string(dest_tk)));
     }
     return DDS::RETCODE_OK;
   }
 
   DDS::ReturnCode_t rc = DDS::RETCODE_OK;
   switch (src_tk) {
   case TK_BOOLEAN:
   case TK_BYTE:
   case TK_INT8:
   case TK_INT16:
   case TK_INT32:
   case TK_INT64:
   case TK_UINT8:
   case TK_UINT16:
   case TK_UINT32:
   case TK_UINT64:
   case TK_FLOAT32:
   case TK_FLOAT64:
   case TK_FLOAT128:
   case TK_CHAR8:
   case TK_CHAR16:
   case TK_STRING8:
   case TK_STRING16:
   case TK_ENUM:
     return copy_member(dest, MEMBER_ID_INVALID, src, MEMBER_ID_INVALID);
 
   case TK_UNION:
     {
       if (src->get_item_count() == 2) {
         const DDS::MemberId id = src->get_member_id_at_index(1);
         rc = copy_member(dest, id, src, id);
         if (rc != DDS::RETCODE_OK) {
           if (log_level >= LogLevel::Warning) {
             ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
               "Couldn't set union branch: %C\n", retcode_to_string(rc)));
           }
           return rc;
         }
       }
       rc = copy_member(dest, DISCRIMINATOR_ID, src, DISCRIMINATOR_ID);
       if (rc != DDS::RETCODE_OK && log_level >= LogLevel::Warning) {
         ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
           "Couldn't set union disciminator: %C\n", retcode_to_string(rc)));
       }
       return rc;
     }
 
   case TK_STRUCTURE:
     {
       DDS::DynamicTypeMembersById_var src_members_var;
       rc = actual_src_type->get_all_members(src_members_var);
       if (rc != DDS::RETCODE_OK) {
         return rc;
       }
       DynamicTypeMembersByIdImpl* src_members =
         dynamic_cast<DynamicTypeMembersByIdImpl*>(src_members_var.in());
 
       DDS::DynamicTypeMembersById_var dest_members_var;
       rc = actual_dest_type->get_all_members(dest_members_var);
       if (rc != DDS::RETCODE_OK) {
         return rc;
       }
       DynamicTypeMembersByIdImpl* dest_members =
         dynamic_cast<DynamicTypeMembersByIdImpl*>(dest_members_var.in());
 
       for (DynamicTypeMembersByIdImpl::const_iterator src_it = src_members->begin();
           src_it != src_members->end(); ++src_it) {
         const DDS::MemberId id = src_it->first;
         const DynamicTypeMembersByIdImpl::const_iterator dest_it = dest_members->find(id);
         if (dest_it == dest_members->end()) {
           continue;
         }
 
         const DDS::ReturnCode_t this_rc = copy_member(dest, id, src, id);
         if (this_rc != DDS::RETCODE_OK && rc == DDS::RETCODE_OK) {
           rc = this_rc;
         }
       }
     }
     break;
 
   case TK_SEQUENCE:
   case TK_ARRAY:
     {
       const DDS::UInt32 count = src->get_item_count();
       for (DDS::UInt32 i = 0; i < count; ++i) {
         const DDS::ReturnCode_t this_rc = copy_member(
           dest, dest->get_member_id_at_index(i),
           src, src->get_member_id_at_index(i));
         if (this_rc != DDS::RETCODE_OK && rc == DDS::RETCODE_OK) {
           rc = this_rc;
         }
       }
     }
     break;
 
   case TK_MAP:
   case TK_BITSET:
   case TK_ALIAS:
   case TK_ANNOTATION:
   default:
     if (log_level >= LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
         "member has unexpected TypeKind %C\n", typekind_to_string(src_tk)));
     }
     rc = DDS::RETCODE_UNSUPPORTED;
   }
 
   return rc;
 }

◆ copy_member()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::copy_member	(	DDS::DynamicData_ptr	dest,
		DDS::MemberId	dest_id,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	src_id
	)

Definition at line 1197 of file XTypes/Utils.cpp.

References ACE_DEBUG, ACE_ERROR, copy(), OpenDDS::DCPS::DCPS_debug_level, get_base_type(), get_enum_value(), get_int_value(), get_member_type(), get_uint_value(), TAO::String_var< charT >::in(), LM_DEBUG, LM_WARNING, OpenDDS::DCPS::log_level, MEMBER_ID_INVALID, DDS::RETCODE_NO_DATA, DDS::RETCODE_OK, OpenDDS::DCPS::retcode_to_string(), DDS::RETCODE_UNSUPPORTED, set_enum_value(), set_int_value(), set_uint_value(), TK_ALIAS, TK_ANNOTATION, TK_ARRAY, TK_BITSET, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_ENUM, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_MAP, TK_SEQUENCE, TK_STRING16, TK_STRING8, TK_STRUCTURE, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, TK_UNION, typekind_to_string(), value, and OpenDDS::DCPS::LogLevel::Warning.

Referenced by copy(), and set_enum_value().

 {
   DDS::ReturnCode_t rc = DDS::RETCODE_OK;
   if (dest == src) {
     return rc;
   }
 
   const DDS::DynamicType_var dest_type = dest->type();
   DDS::DynamicType_var use_dest_type;
   if (dest_id != MEMBER_ID_INVALID) {
     rc = get_member_type(use_dest_type, dest_type, dest_id);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
   } else {
     use_dest_type = get_base_type(dest_type);
   }
   const DDS::TypeKind dest_tk = use_dest_type->get_kind();
 
   const DDS::DynamicType_var src_type = src->type();
   DDS::DynamicType_var use_src_type;
   if (src_id != MEMBER_ID_INVALID) {
     rc = get_member_type(use_src_type, src_type, src_id);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
   } else {
     use_src_type = get_base_type(src_type);
   }
   const DDS::TypeKind src_tk = use_src_type->get_kind();
 
   if (DCPS::DCPS_debug_level >= 8) {
     const CORBA::String_var src_type_name = src_type->get_name();
     const CORBA::String_var dest_type_name = dest_type->get_name();
     ACE_DEBUG((LM_DEBUG, "(%P|%t) copy_member(DynamicData): "
       "type %C from %C id %u to %C id %u\n",
       typekind_to_string(src_tk), src_type_name.in(), src_id, dest_type_name.in(), dest_id));
   }
 
   if (src_tk != dest_tk) {
     if (log_level >= LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy_member(DynamicData): "
         "Can not copy member type %C id %u to type %C id %u\n",
         typekind_to_string(src_tk), src_id, typekind_to_string(dest_tk), dest_id));
     }
     return DDS::RETCODE_OK;
   }
 
   DDS::ReturnCode_t get_rc = DDS::RETCODE_OK;
   DDS::ReturnCode_t set_rc = DDS::RETCODE_OK;
   switch (src_tk) {
   case TK_BOOLEAN:
     {
       DDS::Boolean value;
       get_rc = src->get_boolean_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_boolean_value(dest_id, value);
       }
     }
     break;
 
   case TK_BYTE:
     {
       DDS::Byte value;
       get_rc = src->get_byte_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_byte_value(dest_id, value);
       }
     }
     break;
 
   case TK_INT8:
   case TK_INT16:
   case TK_INT32:
   case TK_INT64:
     {
       DDS::Int64 value;
       get_rc = get_int_value(value, src, src_id, src_tk);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = set_int_value(dest, dest_id, dest_tk, value);
       }
     }
     break;
 
   case TK_UINT8:
   case TK_UINT16:
   case TK_UINT32:
   case TK_UINT64:
     {
       DDS::UInt64 value;
       get_rc = get_uint_value(value, src, src_id, src_tk);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = set_uint_value(dest, dest_id, dest_tk, value);
       }
     }
     break;
 
   case TK_FLOAT32:
     {
       DDS::Float32 value;
       get_rc = src->get_float32_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_float32_value(dest_id, value);
       }
     }
     break;
 
   case TK_FLOAT64:
     {
       DDS::Float64 value;
       get_rc = src->get_float64_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_float64_value(dest_id, value);
       }
     }
     break;
 
   case TK_FLOAT128:
     {
       DDS::Float128 value;
       get_rc = src->get_float128_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_float128_value(dest_id, value);
       }
     }
     break;
 
   case TK_CHAR8:
     {
       DDS::Char8 value;
       get_rc = src->get_char8_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_char8_value(dest_id, value);
       }
     }
     break;
 
   case TK_CHAR16:
     {
       DDS::Char16 value;
       get_rc = src->get_char16_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_char16_value(dest_id, value);
       }
     }
     break;
 
   case TK_STRING8:
     {
       CORBA::String_var value;
       get_rc = src->get_string_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_string_value(dest_id, value);
       }
     }
     break;
 
   case TK_STRING16:
     {
       CORBA::WString_var value;
       get_rc = src->get_wstring_value(value, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = dest->set_wstring_value(dest_id, value);
       }
     }
     break;
 
   case TK_ENUM:
     {
       DDS::Int32 value;
       get_rc = get_enum_value(value, use_src_type, src, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         set_rc = set_enum_value(use_dest_type, dest, dest_id, value);
       }
     }
     break;
 
   case TK_STRUCTURE:
   case TK_UNION:
   case TK_SEQUENCE:
   case TK_ARRAY:
     {
       DDS::DynamicData_var subsrc;
       get_rc = src->get_complex_value(subsrc, src_id);
       if (get_rc == DDS::RETCODE_OK) {
         DDS::DynamicData_var subdest;
         get_rc = dest->get_complex_value(subdest, dest_id);
         if (get_rc == DDS::RETCODE_OK) {
           set_rc = copy(subdest, subsrc);
         }
       }
     }
     break;
 
   case TK_MAP:
   case TK_BITSET:
   case TK_ALIAS:
   case TK_ANNOTATION:
   default:
     if (log_level >= LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
         "member has unexpected TypeKind %C\n", typekind_to_string(src_tk)));
     }
     get_rc = DDS::RETCODE_UNSUPPORTED;
   }
 
   if (get_rc == DDS::RETCODE_NO_DATA) {
     if (DCPS::DCPS_debug_level >= 8) {
       const CORBA::String_var src_type_name = src_type->get_name();
       const CORBA::String_var dest_type_name = dest_type->get_name();
       ACE_DEBUG((LM_DEBUG, "(%P|%t) copy(DynamicData): "
         "Did not copy member type %C from %C id %u to %C id %u: get returned %C\n",
         typekind_to_string(src_tk), src_type_name.in(), src_id, dest_type_name.in(), dest_id,
         retcode_to_string(get_rc)));
     }
     return DDS::RETCODE_OK;
   }
 
   if (get_rc != DDS::RETCODE_OK || set_rc != DDS::RETCODE_OK) {
     if (log_level >= LogLevel::Warning) {
       const CORBA::String_var src_type_name = src_type->get_name();
       const CORBA::String_var dest_type_name = dest_type->get_name();
       const DDS::TypeKind tk = src_type->get_kind();
       if (tk == TK_STRUCTURE || tk == TK_UNION) {
         CORBA::String_var src_member_name;
         DDS::MemberDescriptor_var src_md;
         DDS::ReturnCode_t rc = src->get_descriptor(src_md, src_id);
         if (rc == DDS::RETCODE_OK) {
           src_member_name = src_md->name();
         }
         CORBA::String_var dest_member_name;
         DDS::MemberDescriptor_var dest_md;
         rc = dest->get_descriptor(dest_md, dest_id);
         if (rc == DDS::RETCODE_OK) {
           dest_member_name = dest_md->name();
         }
         ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
           "Could not copy member type %C from %C.%C id %u to %C.%C id %u: get: %C set: %C\n",
           typekind_to_string(src_tk),
           src_type_name.in(), src_member_name.in() ? src_member_name.in() : "?", src_id,
           dest_type_name.in(), dest_member_name.in() ? dest_member_name.in() : "?", dest_id,
           retcode_to_string(get_rc), retcode_to_string(set_rc)));
       } else {
         ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: copy(DynamicData): "
           "Could not copy member type %C from %C id %u to %C id %u: get: %C set: %C\n",
           typekind_to_string(src_tk), src_type_name.in(), src_id, dest_type_name.in(), dest_id,
           retcode_to_string(get_rc), retcode_to_string(set_rc)));
       }
     }
     rc = get_rc != DDS::RETCODE_OK ? get_rc : set_rc;
   }
 
   return rc;
 }

◆ dds_to_opendds_ext()

OpenDDS_Dcps_Export DCPS::Extensibility OpenDDS::XTypes::dds_to_opendds_ext ( DDS::ExtensibilityKind ext )

Definition at line 99 of file XTypes/Utils.cpp.

References DDS::APPENDABLE, OpenDDS::DCPS::APPENDABLE, DDS::FINAL, OpenDDS::DCPS::FINAL, DDS::MUTABLE, OpenDDS::DCPS::MUTABLE, and OPENDDS_ASSERT.

Referenced by dynamic_type_is_valid(), and extensibility().

 {
   switch (ext) {
   case DDS::FINAL:
     return DCPS::FINAL;
   case DDS::APPENDABLE:
     return DCPS::APPENDABLE;
   case DDS::MUTABLE:
     return DCPS::MUTABLE;
   }
   OPENDDS_ASSERT(false);
   return DCPS::FINAL;
 }

◆ deserialize_type_info()

template<typename T >

bool OpenDDS::XTypes::deserialize_type_info	(	TypeInformation &	type_info,
		const T &	seq
	)

Definition at line 3397 of file TypeObject.h.

References ACE_ERROR, ACE_TEXT(), get_typeobject_encoding(), has_type_object(), hash_member_name(), hash_member_name_to_id(), is_fully_descriptive(), is_plain_collection(), LM_ERROR, name, OpenDDS_Dcps_Export, OPENDDS_MAP(), and OPENDDS_STRING.

Referenced by OpenDDS::RTPS::Sedp::match_continue().

   {
     DCPS::MessageBlockHelper<T> helper(seq);
     DCPS::Serializer serializer(helper, XTypes::get_typeobject_encoding());
     if (!(serializer >> type_info)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: deserialize_type_info ")
                  ACE_TEXT("deserialization of type information failed.\n")));
       return false;
     }
     return true;
   }

◆ dynamic_type_is_valid()

bool OpenDDS::XTypes::dynamic_type_is_valid ( DDS::DynamicType_ptr type )

inline

Definition at line 20 of file XTypes/Utils.h.

References dds_to_opendds_ext(), extensibility(), max_extensibility(), OpenDDS_Dcps_Export, and DDS::RETCODE_OK.

Referenced by OpenDDS::DCPS::DomainParticipantImpl::get_dynamic_type().

 {
   DDS::TypeDescriptor_var td;
   return type && type->get_descriptor(td) == DDS::RETCODE_OK && td;
 }

◆ DynamicDataImpl::get_boolean_from_bitmask< CORBA::UInt8 >()

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_boolean_from_bitmask< CORBA::UInt8 >	(	CORBA::ULong	index,
		CORBA::Boolean &	value
	)

Definition at line 3138 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataImpl::read_basic_value(), and ACE_OutputCDR::from_int8::val_.

 {
   ACE_OutputCDR::from_int8 bitmask(0);
   if (!read_basic_value(bitmask)) {
     return false;
   }
   value = ((1 << index) & bitmask.val_) ? true : false;
   return true;
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::BooleanSeq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::BooleanSeq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3443 of file DynamicDataImpl.cpp.

 {
   const DDS::BooleanSeq& values = it->second.get<DDS::BooleanSeq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, ACE_OutputCDR::from_boolean(values[i]));
   }
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::ByteSeq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::ByteSeq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3433 of file DynamicDataImpl.cpp.

 {
   const DDS::ByteSeq& values = it->second.get<DDS::ByteSeq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, ACE_OutputCDR::from_octet(values[i]));
   }
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::CharSeq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::CharSeq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3423 of file DynamicDataImpl.cpp.

 {
   const DDS::CharSeq& values = it->second.get<DDS::CharSeq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, ACE_OutputCDR::from_char(values[i]));
   }
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::Int8Seq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::Int8Seq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3403 of file DynamicDataImpl.cpp.

 {
   const DDS::Int8Seq& values = it->second.get<DDS::Int8Seq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, ACE_OutputCDR::from_int8(values[i]));
   }
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::StringSeq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::StringSeq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3381 of file DynamicDataImpl.cpp.

 {
   const DDS::StringSeq& values = it->second.get<DDS::StringSeq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, values[i].in());
   }
 }

◆ DynamicDataImpl::move_sequence_helper< DDS::UInt8Seq >()

template<>

void OpenDDS::XTypes::DynamicDataImpl::move_sequence_helper< DDS::UInt8Seq >	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

Definition at line 3413 of file DynamicDataImpl.cpp.

 {
   const DDS::UInt8Seq& values = it->second.get<DDS::UInt8Seq>();
   for (CORBA::ULong i = 0; i < values.length(); ++i) {
     data->insert_single(i, ACE_OutputCDR::from_uint8(values[i]));
   }
 }

◆ enum_bound()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::enum_bound	(	DDS::DynamicType_ptr	enum_type,
		DDS::TypeKind &	bound_kind
	)

Definition at line 1074 of file XTypes/Utils.cpp.

References ACE_ERROR, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_ENUM, TK_INT16, TK_INT32, TK_INT8, and typekind_to_string().

Referenced by OpenDDS::XTypes::DynamicDataBase::check_member(), OpenDDS::XTypes::DynamicDataImpl::clear_value_i(), get_enum_value(), get_member_type(), OpenDDS::XTypes::DynamicDataImpl::get_value_from_collection(), OpenDDS::XTypes::DynamicDataImpl::get_value_from_enum(), OpenDDS::XTypes::DynamicDataImpl::move_single_to_complex(), set_enum_value(), and OpenDDS::XTypes::DynamicDataImpl::write_discriminator().

 {
   const DDS::TypeKind kind = enum_type->get_kind();
   if (kind != TK_ENUM) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: enum_bound: "
         "expected enum, got %C\n",
         typekind_to_string(kind)));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
 
   DDS::TypeDescriptor_var td;
   const DDS::ReturnCode_t rc = enum_type->get_descriptor(td);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   const size_t bound_size = td->bound()[0];
   if (bound_size >= 1 && bound_size <= 8) {
     bound_kind = TK_INT8;
   } else if (bound_size >= 9 && bound_size <= 16) {
     bound_kind = TK_INT16;
   } else if (bound_size >= 17 && bound_size <= 32) {
     bound_kind = TK_INT32;
   } else {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: enum_bound: "
         "Got unexpected bound size %B\n",
         bound_size));
     }
     return DDS::RETCODE_BAD_PARAMETER;
   }
   return DDS::RETCODE_OK;
 }

◆ equivalence_hash_to_string()

OpenDDS_Dcps_Export DCPS::String OpenDDS::XTypes::equivalence_hash_to_string ( const EquivalenceHash & equivalence_hash )

Definition at line 33 of file TypeObject.cpp.

References OpenDDS::DCPS::to_dds_string().

Referenced by OpenDDS::XTypes::TypeLookupService::get_minimal_type_identifier(), and OpenDDS::DCPS::TypeSupportImpl::get_type_name().

 {
   return DCPS::to_dds_string(&equivalence_hash[0], sizeof equivalence_hash);
 }

◆ extensibility() [1/2]

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::extensibility	(	DDS::DynamicType_ptr	type,
		DCPS::Extensibility &	ext
	)

Definition at line 27 of file XTypes/Utils.cpp.

References dds_to_opendds_ext(), OpenDDS::DCPS::FINAL, get_base_type(), DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_STRUCTURE, and TK_UNION.

 {
   DDS::DynamicType_var base_type = get_base_type(type);
   if (!base_type) {
     return DDS::RETCODE_BAD_PARAMETER;
   }
   switch (base_type->get_kind()) {
   case TK_STRUCTURE:
   case TK_UNION:
     {
       DDS::TypeDescriptor_var td;
       const DDS::ReturnCode_t rc = type->get_descriptor(td);
       if (rc != DDS::RETCODE_OK) {
         return rc;
       }
       ext = dds_to_opendds_ext(td->extensibility_kind());
     }
     break;
   default:
     ext = DCPS::FINAL;
   }
   return DDS::RETCODE_OK;
 }

◆ extensibility() [2/2]

OpenDDS::XTypes::extensibility ( MUTABLE )

Definition at line 29 of file TypeLookup.idl.

References OpenDDS::DCPS::MUTABLE.

Referenced by DDS::DynamicTypeSupport::base_extensibility(), OpenDDS::DCPS::TypeSupportImpl_T< NativeType >::base_extensibility(), OpenDDS::RTPS::Sedp::Reader::data_received(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::DataContainer(), OpenDDS::RTPS::Sedp::DiscoveryReader::DiscoveryReader(), dynamic_type_is_valid(), invalid_option(), OpenDDS::RTPS::Sedp::LivelinessReader::LivelinessReader(), max_extensibility(), OpenDDS::RTPS::Sedp::Reader::remove_associations(), OpenDDS::RTPS::Sedp::SecurityReader::SecurityReader(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_structure_xcdr2(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_union_xcdr2(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_structure_xcdr2(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_union_xcdr2(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_all(), OpenDDS::RTPS::Sedp::TypeLookupReplyReader::TypeLookupReplyReader(), and OpenDDS::RTPS::Sedp::TypeLookupRequestReader::TypeLookupRequestReader().

                                   {
       @hashid TypeIdentifierSeq type_ids;
     };

◆ get_base_type()

OpenDDS_Dcps_Export DDS::DynamicType_var OpenDDS::XTypes::get_base_type ( DDS::DynamicType_ptr type )

Definition at line 177 of file DynamicTypeImpl.cpp.

References DDS::RETCODE_OK, and TK_ALIAS.

 {
   if (!type) {
     return 0;
   }
 
   DDS::DynamicType_var t = DDS::DynamicType::_duplicate(type);
   if (t->get_kind() != TK_ALIAS) {
     return t;
   }
 
   DDS::TypeDescriptor_var descriptor;
   if (t->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return 0;
   }
 
   return get_base_type(descriptor->base_type());
 }

◆ get_bitmask_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_bitmask_value	(	DDS::UInt64 &	value,
		DDS::DynamicType_ptr	type,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	id
	)

Definition at line 1063 of file XTypes/Utils.cpp.

References bitmask_bound(), get_uint_value(), and DDS::RETCODE_OK.

Referenced by get_member_type(), and is_key().

 {
   DDS::TypeKind bound_kind;
   const DDS::ReturnCode_t rc = bitmask_bound(type, bound_kind);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return get_uint_value(value, src, id, bound_kind);
 }

◆ get_dynamic_data_adapter() [1/4]

template<typename T , typename Tag >

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter	(	DDS::DynamicType_ptr	type,
		const T &	value
	)

Definition at line 39 of file DynamicDataAdapter.h.

References get_dynamic_data_adapter_value(), and value.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< DynamicSample >::store_instance_data_check().

 {
   return get_dynamic_data_adapter<T, T>(type, value);
 }

◆ get_dynamic_data_adapter() [2/4]

template<typename T , typename Tag >

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter	(	DDS::DynamicType_ptr	type,
		T &	value
	)

Definition at line 33 of file DynamicDataAdapter.h.

References value.

 {
   return get_dynamic_data_adapter<T, T>(type, value);
 }

◆ get_dynamic_data_adapter() [3/4]

template<typename T >

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter	(	DDS::DynamicType_ptr	type,
		T &	value
	)

Definition at line 33 of file DynamicDataAdapter.h.

References value.

 {
   return get_dynamic_data_adapter<T, T>(type, value);
 }

◆ get_dynamic_data_adapter() [4/4]

template<typename T >

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter	(	DDS::DynamicType_ptr	type,
		const T &	value
	)

Definition at line 39 of file DynamicDataAdapter.h.

References get_dynamic_data_adapter_value(), and value.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< DynamicSample >::store_instance_data_check().

 {
   return get_dynamic_data_adapter<T, T>(type, value);
 }

◆ get_dynamic_data_adapter< DynamicSample, DynamicSample >() [1/2]

template<>

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter< DynamicSample, DynamicSample >	(	DDS::DynamicType_ptr	,
		const DynamicSample &	value
	)

Definition at line 213 of file DynamicTypeSupport.cpp.

References value.

     {
       return value.dynamic_data()._retn();
     }

◆ get_dynamic_data_adapter< DynamicSample, DynamicSample >() [2/2]

template<>

DDS::DynamicData_ptr OpenDDS::XTypes::get_dynamic_data_adapter< DynamicSample, DynamicSample >	(	DDS::DynamicType_ptr	,
		DynamicSample &	value
	)

Definition at line 220 of file DynamicTypeSupport.cpp.

References value.

     {
       return value.dynamic_data()._retn();
     }

◆ get_dynamic_data_adapter_value()

template<typename T , typename Tag >

const T* OpenDDS::XTypes::get_dynamic_data_adapter_value ( DDS::DynamicData_ptr dda )

Referenced by get_dynamic_data_adapter().

◆ get_enum_value() [1/2]

DDS::ReturnCode_t OpenDDS::XTypes::get_enum_value	(	DDS::Int32 &	value,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	id
	)

inline

Definition at line 175 of file XTypes/Utils.h.

References get_enum_value(), get_member_type(), OpenDDS_Dcps_Export, DDS::RETCODE_OK, and set_enum_value().

 {
   DDS::DynamicType_var enum_type;
   const DDS::ReturnCode_t rc = get_member_type(enum_type, src, id);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return get_enum_value(value, enum_type, src, id);
 }

◆ get_enum_value() [2/2]

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_enum_value	(	DDS::Int32 &	value,
		DDS::DynamicType_ptr	enum_type,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	id
	)

Definition at line 1110 of file XTypes/Utils.cpp.

References enum_bound(), get_int_value(), and DDS::RETCODE_OK.

Referenced by copy_member(), OpenDDS::XTypes::DynamicDataBase::enum_string_helper(), get_enum_value(), OpenDDS::XTypes::DynamicDataBase::get_int64_value(), get_member_type(), OpenDDS::XTypes::DynamicDataImpl::get_simple_value_enum(), is_key(), and print_member().

 {
   DDS::TypeKind bound_kind;
   DDS::ReturnCode_t rc = enum_bound(enum_type, bound_kind);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   DDS::Int64 v = 0;
   rc = get_int_value(v, src, id, bound_kind);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   value = static_cast<DDS::Int32>(v);
   return rc;
 }

◆ get_enumerator_name()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_enumerator_name	(	DDS::String8_var &	name,
		DDS::Int32	value,
		DDS::DynamicType_ptr	type
	)

Definition at line 1127 of file XTypes/Utils.cpp.

References DDS::RETCODE_OK.

Referenced by OpenDDS::XTypes::DynamicDataBase::enum_string_helper(), OpenDDS::XTypes::DynamicDataImpl::get_simple_value_enum(), print_member(), and set_enum_value().

 {
   DDS::DynamicTypeMember_var dtm;
   DDS::ReturnCode_t rc = type->get_member(dtm, static_cast<DDS::MemberId>(value));
   if (rc != DDS::RETCODE_OK) {
      return rc;
    }
 
   DDS::MemberDescriptor_var md;
   rc = dtm->get_descriptor(md);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   name = md->name();
   return DDS::RETCODE_OK;
 }

◆ get_enumerator_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_enumerator_value	(	DDS::Int32 &	value,
		const char *	name,
		DDS::DynamicType_ptr	type
	)

Definition at line 1146 of file XTypes/Utils.cpp.

References DDS::RETCODE_OK.

Referenced by set_enum_value(), and OpenDDS::XTypes::DynamicDataImpl::set_string_value().

 {
   DDS::DynamicTypeMember_var dtm;
   DDS::ReturnCode_t rc = type->get_member_by_name(dtm, name);
   if (rc != DDS::RETCODE_OK) {
      return rc;
    }
 
   DDS::MemberDescriptor_var md;
   rc = dtm->get_descriptor(md);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   value = static_cast<DDS::Int32>(md->id());
   return DDS::RETCODE_OK;
 }

◆ get_int_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_int_value	(	DDS::Int64 &	value,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	id,
		DDS::TypeKind	kind
	)

Definition at line 960 of file XTypes/Utils.cpp.

References DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_INT16, TK_INT32, TK_INT64, and TK_INT8.

Referenced by copy_member(), get_enum_value(), OpenDDS::XTypes::DynamicDataBase::get_int64_value(), get_member_type(), OpenDDS::XTypes::DynamicDataBase::get_uint64_value(), is_key(), and print_member().

 {
   DDS::ReturnCode_t rc = DDS::RETCODE_BAD_PARAMETER;
   switch (kind) {
   case TK_INT8:
     {
       DDS::Int8 v;
       rc = src->get_int8_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_INT16:
     {
       DDS::Int16 v;
       rc = src->get_int16_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_INT32:
     {
       DDS::Int32 v;
       rc = src->get_int32_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_INT64:
     rc = src->get_int64_value(value, id);
     break;
   }
   return rc;
 }

◆ get_keys()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_keys	(	DDS::DynamicType_ptr	type,
		MemberPathVec &	paths
	)

Definition at line 463 of file XTypes/Utils.cpp.

References Filter_Keys, and get_values().

Referenced by is_key(), and key_count().

 {
   return get_values(type, paths, Filter_Keys);
 }

◆ get_member_type() [1/2]

DDS::ReturnCode_t OpenDDS::XTypes::get_member_type	(	DDS::DynamicType_var &	member_type,
		DDS::DynamicData_ptr	container,
		DDS::MemberId	id
	)

inline

Definition at line 148 of file XTypes/Utils.h.

References bitmask_bound(), bound_total(), enum_bound(), get_bitmask_value(), get_enum_value(), get_int_value(), get_member_type(), get_uint_value(), OpenDDS_Dcps_Export, set_int_value(), set_uint_value(), and value.

 {
   DDS::DynamicType_var container_type = container->type();
   return get_member_type(member_type, container_type, id);
 }

◆ get_member_type() [2/2]

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_member_type	(	DDS::DynamicType_var &	member_type,
		DDS::DynamicType_ptr	container_type,
		DDS::MemberId	id
	)

Definition at line 870 of file XTypes/Utils.cpp.

References ACE_ERROR, get_base_type(), is_scalar(), is_sequence_like(), LM_WARNING, OpenDDS::DCPS::log_level, MEMBER_ID_INVALID, DDS::RETCODE_OK, typekind_to_string(), and OpenDDS::DCPS::LogLevel::Warning.

Referenced by copy_member(), OpenDDS::XTypes::DynamicDataBase::enum_string_helper(), get_enum_value(), OpenDDS::XTypes::DynamicDataBase::get_int64_value(), get_member_type(), OpenDDS::XTypes::DynamicDataImpl::get_simple_value_enum(), OpenDDS::XTypes::DynamicDataBase::get_uint64_value(), is_key(), set_enum_value(), and OpenDDS::XTypes::DynamicDataImpl::set_string_value().

 {
   const DDS::TypeKind container_kind = container_type->get_kind();
   if (is_sequence_like(container_kind)) {
     DDS::TypeDescriptor_var td;
     DDS::ReturnCode_t rc = container_type->get_descriptor(td);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     member_type = get_base_type(td->element_type());
   } else if (is_scalar(container_kind)) {
     if (id != MEMBER_ID_INVALID && log_level >= LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: get_member_type: "
         "Accessing a %C DynamicData via id %u, not MEMBER_ID_INVALID\n",
         typekind_to_string(container_kind), id));
     }
     member_type = DDS::DynamicType::_duplicate(container_type);
     return DDS::RETCODE_OK;
   } else {
     DDS::DynamicTypeMember_var dtm;
     DDS::ReturnCode_t rc = container_type->get_member(dtm, id);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     DDS::MemberDescriptor_var md;
     rc = dtm->get_descriptor(md);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     member_type = get_base_type(md->type());
   }
   return DDS::RETCODE_OK;
 }

◆ get_typeobject_encoding()

OpenDDS_Dcps_Export const DCPS::Encoding & OpenDDS::XTypes::get_typeobject_encoding ( )

Definition at line 27 of file TypeObject.cpp.

References OpenDDS::STUN::encoding(), OpenDDS::DCPS::ENDIAN_LITTLE, and OpenDDS::DCPS::Encoding::KIND_XCDR2.

Referenced by OpenDDS::DCPS::TypeSupportImpl::add_types(), deserialize_type_info(), OpenDDS::XTypes::TypeLookupService::get_type_dependencies_i(), makeTypeIdentifier(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::TypeSupportImpl::populate_dependencies_i(), serialize_type_info(), typeobject_generator::strong_connect(), OpenDDS::DCPS::TypeSupportImpl::to_type_info_i(), OpenDDS::DCPS::to_type_object(), and typeobject_generator::use_old_typeobject_encoding().

 {
   static const Encoding encoding(Encoding::KIND_XCDR2, DCPS::ENDIAN_LITTLE);
   return encoding;
 }

◆ get_uint_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_uint_value	(	DDS::UInt64 &	value,
		DDS::DynamicData_ptr	src,
		DDS::MemberId	id,
		DDS::TypeKind	kind
	)

Definition at line 905 of file XTypes/Utils.cpp.

References DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_UINT16, TK_UINT32, TK_UINT64, and TK_UINT8.

Referenced by copy_member(), get_bitmask_value(), OpenDDS::XTypes::DynamicDataBase::get_int64_value(), get_member_type(), OpenDDS::XTypes::DynamicDataBase::get_uint64_value(), is_key(), and print_member().

 {
   DDS::ReturnCode_t rc = DDS::RETCODE_BAD_PARAMETER;
   switch (kind) {
   case TK_UINT8:
     {
       DDS::UInt8 v;
       rc = src->get_uint8_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_UINT16:
     {
       DDS::UInt16 v;
       rc = src->get_uint16_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_UINT32:
     {
       DDS::UInt32 v;
       rc = src->get_uint32_value(v, id);
       if (rc == DDS::RETCODE_OK) {
         value = v;
       }
     }
     break;
   case TK_UINT64:
     rc = src->get_uint64_value(value, id);
     break;
   }
   return rc;
 }

◆ get_values()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::get_values	(	DDS::DynamicType_ptr	type,
		MemberPathVec &	paths,
		Filter	filter
	)

Definition at line 458 of file XTypes/Utils.cpp.

Referenced by get_keys(), and less_than().

 {
   return get_values_i(type, paths, filter, MemberPath());
 }

◆ has_type_object()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::has_type_object ( const TypeIdentifier & ti )

Definition at line 461 of file TypeObject.cpp.

Referenced by deserialize_type_info(), and OpenDDS::DCPS::TypeSupportImpl::populate_dependencies_i().

 {
   return !is_fully_descriptive(ti) && !is_plain_collection(ti) &&
     ti.kind() != TK_NONE;
 }

◆ hash_member_name()

OpenDDS_Dcps_Export void OpenDDS::XTypes::hash_member_name	(	NameHash &	name_hash,
		const OPENDDS_STRING &	name
	)

Definition at line 400 of file TypeObject.cpp.

References OpenDDS::DCPS::MD5Hash().

Referenced by OpenDDS::XTypes::TypeLookupService::complete_to_minimal_annotation(), OpenDDS::XTypes::TypeLookupService::complete_to_minimal_bitmask(), OpenDDS::XTypes::TypeLookupService::complete_to_minimal_bitset(), OpenDDS::XTypes::TypeLookupService::complete_to_minimal_enumerated(), OpenDDS::XTypes::TypeLookupService::complete_to_minimal_struct(), OpenDDS::XTypes::TypeLookupService::complete_to_minimal_union(), deserialize_type_info(), typeobject_generator::generate_enum_type_identifier(), typeobject_generator::generate_struct_type_identifier(), and typeobject_generator::generate_union_type_identifier().

 {
   unsigned char result[16];
   DCPS::MD5Hash(result, name.c_str(), name.size());
 
   std::memcpy(&name_hash, result, sizeof name_hash);
 }

◆ hash_member_name_to_id()

OpenDDS_Dcps_Export ACE_CDR::ULong OpenDDS::XTypes::hash_member_name_to_id ( const OPENDDS_STRING & name )

Definition at line 389 of file TypeObject.cpp.

References OpenDDS::DCPS::MD5Hash(), and OpenDDS::DCPS::Serializer::MEMBER_ID_MASK.

Referenced by deserialize_type_info(), and invalid_option().

 {
   ACE_CDR::ULong name_hash;
 
   unsigned char result[16];
   DCPS::MD5Hash(result, name.c_str(), name.size());
 
   std::memcpy(&name_hash, result, sizeof name_hash);
   return name_hash & DCPS::Serializer::MEMBER_ID_MASK;
 }

◆ is_basic()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_basic ( TypeKind tk )

Definition at line 1220 of file TypeObject.cpp.

References is_primitive(), TK_STRING16, and TK_STRING8.

 {
   return is_primitive(tk) || tk == TK_STRING8 || tk == TK_STRING16;
 }

◆ is_complex()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_complex ( TypeKind tk )

Definition at line 1225 of file TypeObject.cpp.

References TK_ARRAY, TK_BITSET, TK_MAP, TK_SEQUENCE, TK_STRUCTURE, and TK_UNION.

Referenced by OpenDDS::XTypes::DynamicDataBase::check_member(), OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &(), and print_member().

 {
   switch (tk) {
   case TK_ARRAY:
   case TK_SEQUENCE:
   case TK_MAP:
   case TK_STRUCTURE:
   case TK_UNION:
   case TK_BITSET:
     return true;
   default:
     return false;
   }
 }

◆ is_fully_descriptive()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_fully_descriptive ( const TypeIdentifier & ti )

Definition at line 408 of file TypeObject.cpp.

References EK_BOTH, OpenDDS::XTypes::TypeIdentifier::kind(), TI_PLAIN_ARRAY_LARGE, TI_PLAIN_ARRAY_SMALL, TI_PLAIN_MAP_LARGE, TI_PLAIN_MAP_SMALL, TI_PLAIN_SEQUENCE_LARGE, TI_PLAIN_SEQUENCE_SMALL, TI_STRING16_LARGE, TI_STRING16_SMALL, TI_STRING8_LARGE, TI_STRING8_SMALL, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_UINT16, TK_UINT32, TK_UINT64, and TK_UINT8.

Referenced by deserialize_type_info(), typeobject_generator::generate_array_type_identifier(), typeobject_generator::generate_sequence_type_identifier(), OpenDDS::XTypes::TypeLookupService::get_minimal_type_identifier(), and has_type_object().

 {
   switch (ti.kind()) {
   case TK_BOOLEAN:
   case TK_BYTE:
   case TK_INT16:
   case TK_INT32:
   case TK_INT64:
   case TK_UINT16:
   case TK_UINT32:
   case TK_UINT64:
   case TK_FLOAT32:
   case TK_FLOAT64:
   case TK_FLOAT128:
   case TK_INT8:
   case TK_UINT8:
   case TK_CHAR8:
   case TK_CHAR16:
   case TI_STRING8_SMALL:
   case TI_STRING8_LARGE:
   case TI_STRING16_SMALL:
   case TI_STRING16_LARGE:
     return true;
   case TI_PLAIN_SEQUENCE_SMALL:
     return ti.seq_sdefn().header.equiv_kind == EK_BOTH;
   case TI_PLAIN_SEQUENCE_LARGE:
     return ti.seq_ldefn().header.equiv_kind == EK_BOTH;
   case TI_PLAIN_ARRAY_SMALL:
     return ti.array_sdefn().header.equiv_kind == EK_BOTH;
   case TI_PLAIN_ARRAY_LARGE:
     return ti.array_ldefn().header.equiv_kind == EK_BOTH;
   case TI_PLAIN_MAP_SMALL:
     return ti.map_sdefn().header.equiv_kind == EK_BOTH;
   case TI_PLAIN_MAP_LARGE:
     return ti.map_ldefn().header.equiv_kind == EK_BOTH;
   }
   return false;
 }

◆ is_key()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_key	(	DDS::DynamicType_ptr	type,
		const char *	field
	)

Definition at line 478 of file XTypes/Utils.cpp.

References ACE_ERROR, get_bitmask_value(), get_enum_value(), get_int_value(), get_keys(), get_member_type(), get_uint_value(), TAO::String_var< charT >::in(), LM_NOTICE, LM_WARNING, OpenDDS::DCPS::log_level, name, OpenDDS::DCPS::LogLevel::Notice, OPENDDS_ASSERT, DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, OpenDDS::DCPS::retcode_to_string(), TK_ALIAS, TK_ANNOTATION, TK_ARRAY, TK_BITMASK, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_ENUM, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_SEQUENCE, TK_STRING16, TK_STRING8, TK_STRUCTURE, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, TK_UNION, typekind_to_string(), and OpenDDS::DCPS::LogLevel::Warning.

Referenced by OpenDDS::XTypes::DynamicDataBase::exclude_member(), invalid_option(), DDS::DynamicTypeSupport::is_dcps_key(), OpenDDS::DCPS::TypeSupportImpl_T< NativeType >::is_dcps_key(), and OpenDDS::XTypes::MemberDescriptorImpl::MemberDescriptorImpl().

 {
   MemberPathVec paths;
   if (get_keys(type, paths) != DDS::RETCODE_OK) {
     return false;
   }
   for (size_t i = 0; i < paths.size(); ++i) {
     DDS::DynamicTypeMember_var m;
     if (paths[i].get_member_from_type(type, m) != DDS::RETCODE_OK) {
       return false;
     }
     const CORBA::String_var name = m->get_name();
     if (0 == std::strcmp(name, field)) {
       return true;
     }
   }
   return false;
 }

◆ is_plain_collection()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_plain_collection ( const TypeIdentifier & ti )

Definition at line 447 of file TypeObject.cpp.

References OpenDDS::XTypes::TypeIdentifier::kind(), TI_PLAIN_ARRAY_LARGE, TI_PLAIN_ARRAY_SMALL, TI_PLAIN_MAP_LARGE, TI_PLAIN_MAP_SMALL, TI_PLAIN_SEQUENCE_LARGE, and TI_PLAIN_SEQUENCE_SMALL.

Referenced by deserialize_type_info(), OpenDDS::XTypes::TypeLookupService::get_minimal_type_identifier(), and has_type_object().

 {
   switch (ti.kind()) {
   case TI_PLAIN_SEQUENCE_SMALL:
   case TI_PLAIN_SEQUENCE_LARGE:
   case TI_PLAIN_ARRAY_SMALL:
   case TI_PLAIN_ARRAY_LARGE:
   case TI_PLAIN_MAP_SMALL:
   case TI_PLAIN_MAP_LARGE:
     return true;
   }
   return false;
 }

◆ is_primitive()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_primitive ( TypeKind tk )

Definition at line 1191 of file TypeObject.cpp.

References TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_UINT16, TK_UINT32, TK_UINT64, and TK_UINT8.

 {
   switch (tk) {
   case TK_BOOLEAN:
   case TK_BYTE:
   case TK_INT8:
   case TK_UINT8:
   case TK_INT16:
   case TK_UINT16:
   case TK_INT32:
   case TK_UINT32:
   case TK_INT64:
   case TK_UINT64:
   case TK_FLOAT32:
   case TK_FLOAT64:
   case TK_FLOAT128:
   case TK_CHAR8:
   case TK_CHAR16:
     return true;
   default:
     return false;
   }
 }

◆ is_scalar()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_scalar ( TypeKind tk )

Definition at line 1215 of file TypeObject.cpp.

References is_primitive(), and TK_ENUM.

Referenced by get_member_type(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

 {
   return is_primitive(tk) || tk == TK_ENUM;
 }

◆ is_sequence_like()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::is_sequence_like ( TypeKind tk )

Definition at line 1240 of file TypeObject.cpp.

References MEMBER_NAME_MAX_LENGTH, TK_ARRAY, TK_SEQUENCE, TK_STRING16, TK_STRING8, and TYPE_NAME_MAX_LENGTH.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_largest_complex_index(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_largest_single_index(), get_member_type(), OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &(), and print_member().

 {
   switch (tk) {
   case TK_SEQUENCE:
   case TK_ARRAY:
   case TK_STRING8:
   case TK_STRING16:
     return true;
   default:
     return false;
   }
 }

◆ key_count()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::key_count	(	DDS::DynamicType_ptr	type,
		size_t &	count
	)

Definition at line 468 of file XTypes/Utils.cpp.

References get_keys(), and DDS::RETCODE_OK.

Referenced by metaclass_generator::gen_enum(), keys_generator::gen_struct(), ts_generator::generate_ts(), OpenDDS::DCPS::TypeSupportImpl::get_type(), OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), DDS::DynamicTypeSupport::key_count(), OpenDDS::DCPS::TypeSupportImpl_T< NativeType >::key_count(), and DDS::DynamicTypeSupport::name().

 {
   MemberPathVec paths;
   const DDS::ReturnCode_t rc = get_keys(type, paths);
   if (rc == DDS::RETCODE_OK) {
     count = paths.size();
   }
   return rc;
 }

◆ key_less_than()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::key_less_than	(	bool &	result,
		DDS::DynamicData_ptr	a,
		DDS::DynamicData_ptr	b
	)

Definition at line 860 of file XTypes/Utils.cpp.

References Filter_Keys, and less_than().

Referenced by OpenDDS::XTypes::DynamicSample::compare().

 {
   return less_than(result, a, b, Filter_Keys);
 }

◆ less_than()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::less_than	(	bool &	result,
		DDS::DynamicData_ptr	a,
		DDS::DynamicData_ptr	b,
		Filter	filter
	)

Definition at line 806 of file XTypes/Utils.cpp.

References ACE_ERROR, get_values(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_OK, and OpenDDS::DCPS::retcode_to_string().

Referenced by key_less_than().

 {
   DDS::DynamicType_var a_type = a->type();
   MemberPathVec paths;
   DDS::ReturnCode_t rc = get_values(a_type, paths, filter);
   if (rc != DDS::RETCODE_OK) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: key_compare: get_keys failed: %C\n",
         retcode_to_string(rc)));
     }
     return rc;
   }
 
   result = false;
   for (MemberPathVec::iterator it = paths.begin(); it != paths.end(); it++) {
     DDS::DynamicData_var a_container;
     DDS::MemberId a_member_id;
     rc = it->get_member_from_data(a, a_container, a_member_id);
     if (rc != DDS::RETCODE_OK) {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: key_compare: "
           "get_member_from_data for a failed: %C\n",
           retcode_to_string(rc)));
       }
       return rc;
     }
 
     DDS::DynamicData_var b_container;
     DDS::MemberId b_member_id;
     rc = it->get_member_from_data(b, b_container, b_member_id);
     if (rc != DDS::RETCODE_OK) {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: key_compare: "
           "get_member_from_data for b failed: %C\n",
           retcode_to_string(rc)));
       }
       return rc;
     }
 
     int compare = 0;
     rc = member_compare(compare, a_container, a_member_id, b_container, b_member_id);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     if (compare != 0) {
       result = compare < 0;
       return DDS::RETCODE_OK;
     }
   }
 
   return DDS::RETCODE_OK;
 }

◆ makeTypeIdentifier()

OpenDDS_Dcps_Export TypeIdentifier OpenDDS::XTypes::makeTypeIdentifier	(	const TypeObject &	type_object,
		const DCPS::Encoding *	encoding_option
	)

Definition at line 254 of file TypeObject.cpp.

References EK_COMPLETE, EK_MINIMAL, OpenDDS::STUN::encoding(), get_typeobject_encoding(), OpenDDS::XTypes::TypeObject::kind, ACE_Message_Block::length(), OpenDDS::DCPS::MD5Hash(), OPENDDS_ASSERT, ACE_Message_Block::rd_ptr(), and OpenDDS::DCPS::serialized_size().

Referenced by OpenDDS::DCPS::TypeSupportImpl::add_types(), OpenDDS::DCPS::TypeSupportImpl::to_type_info_i(), and typeobject_generator::update_maps().

 {
   OPENDDS_ASSERT(type_object.kind == EK_MINIMAL || type_object.kind == EK_COMPLETE);
 
   const Encoding& encoding = encoding_option ? *encoding_option : get_typeobject_encoding();
   size_t size = serialized_size(encoding, type_object);
   ACE_Message_Block buff(size);
   DCPS::Serializer ser(&buff, encoding);
   ser << type_object;
 
   unsigned char result[16];
   DCPS::MD5Hash(result, buff.rd_ptr(), buff.length());
 
   // First 14 bytes of MD5 of the serialized TypeObject using XCDR
   // version 2 with Little Endian encoding
   TypeIdentifier ti(type_object.kind);
   std::memcpy(ti.equivalence_hash(), result, sizeof(EquivalenceHash));
 
   return ti;
 }

◆ max_extensibility()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::max_extensibility	(	DDS::DynamicType_ptr	type,
		DCPS::Extensibility &	ext
	)

Definition at line 51 of file XTypes/Utils.cpp.

References OpenDDS::XTypes::DynamicTypeMembersByIdImpl::begin(), OpenDDS::XTypes::DynamicTypeMembersByIdImpl::end(), extensibility(), get_base_type(), DDS::RETCODE_BAD_PARAMETER, DDS::RETCODE_OK, TK_STRUCTURE, and TK_UNION.

Referenced by dynamic_type_is_valid(), OpenDDS::DCPS::TypeSupportImpl::has_dcps_key(), DDS::DynamicTypeSupport::max_extensibility(), and DDS::DynamicTypeSupport::name().

 {
   DDS::ReturnCode_t rc = extensibility(type, ext);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   DDS::DynamicType_var base_type = get_base_type(type);
   const TypeKind tk = base_type->get_kind();
   if (tk != TK_STRUCTURE && tk != TK_UNION) {
     return DDS::RETCODE_OK;
   }
 
   DDS::DynamicTypeMembersById_var members;
   rc = base_type->get_all_members(members);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
 
   DynamicTypeMembersByIdImpl* const members_impl =
     dynamic_cast<DynamicTypeMembersByIdImpl*>(members.in());
   if (!members_impl) {
     return DDS::RETCODE_BAD_PARAMETER;
   }
 
   for (DynamicTypeMembersByIdImpl::const_iterator it = members_impl->begin();
       it != members_impl->end(); ++it) {
     DDS::MemberDescriptor_var md;
     rc = it->second->get_descriptor(md);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
 
     DDS::DynamicType_ptr member_type = md->type();
     if (!member_type) {
       return DDS::RETCODE_BAD_PARAMETER;
     }
     DCPS::Extensibility member_ext;
     DDS::ReturnCode_t rc = max_extensibility(member_type, member_ext);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     ext = std::max(member_ext, ext);
   }
 
   return DDS::RETCODE_OK;
 }

◆ name_hash_equal()

bool OpenDDS::XTypes::name_hash_equal	(	const NameHash &	x,
		const NameHash &	y
	)

inline

Definition at line 301 of file TypeObject.h.

Referenced by name_hash_not_equal(), OpenDDS::XTypes::AppliedAnnotationParameter::operator==(), OpenDDS::XTypes::MinimalMemberDetail::operator==(), OpenDDS::XTypes::MinimalAnnotationParameter::operator==(), and OpenDDS::XTypes::MinimalBitfield::operator==().

   {
     return x[0] == y[0] && x[1] == y[1] && x[2] == y[2] && x[3] == y[3];
   }

◆ name_hash_not_equal()

bool OpenDDS::XTypes::name_hash_not_equal	(	const NameHash &	x,
		const NameHash &	y
	)

inline

Definition at line 306 of file TypeObject.h.

References name_hash_equal().

   {
     return !name_hash_equal(x, y);
   }

◆ OPENDDS_MAP()

typedef OpenDDS::XTypes::OPENDDS_MAP	(	TypeIdentifier	,
		TypeObject
	)

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_enum(), OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::DataContainer(), and deserialize_type_info().

◆ OPENDDS_SET()

typedef OpenDDS::XTypes::OPENDDS_SET ( DynamicTypePtrPair )

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeLookupService::get_type_dependencies_i(), has_type_object(), and OpenDDS::XTypes::TypeMapBuilder::operator TypeMap &().

◆ OPENDDS_VECTOR() [1/2]

typedef OpenDDS::XTypes::OPENDDS_VECTOR ( MemberPair )

Referenced by OpenDDS::XTypes::MemberPath::level().

◆ OPENDDS_VECTOR() [2/2]

typedef OpenDDS::XTypes::OPENDDS_VECTOR ( MemberPath )

◆ operator==() [1/2]

bool OpenDDS::XTypes::operator==	(	const DDS::BoundSeq &	lhs,
		const DDS::BoundSeq &	rhs
	)

inline

Definition at line 66 of file TypeDescriptorImpl.cpp.

 {
   if (lhs.length() == rhs.length()) {
     for (ACE_CDR::ULong i = 0 ; i < lhs.length() ; ++i) {
       if (lhs[i] != rhs[i]) {
         return false;
       }
     }
     return true;
   }
   return false;
 }

◆ operator==() [2/2]

bool OpenDDS::XTypes::operator==	(	const DDS::UnionCaseLabelSeq &	lhs,
		const DDS::UnionCaseLabelSeq &	rhs
	)

inline

Definition at line 71 of file MemberDescriptorImpl.cpp.

References OpenDDS::XTypes::Sequence< T >::length().

 {
   if (lhs.length() == rhs.length()) {
     for (ACE_CDR::ULong i = 0; i < lhs.length(); ++i) {
       if (lhs[i] != rhs[i]) {
         return false;
       }
     }
     return true;
   }
   return false;
 }

◆ print_dynamic_data()

OpenDDS_Dcps_Export bool OpenDDS::XTypes::print_dynamic_data	(	DDS::DynamicData_ptr	dd,
		DCPS::String &	type_string,
		DCPS::String &	indent
	)

Definition at line 3268 of file DynamicDataXcdrReadImpl.cpp.

References get_base_type(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, print_members(), TK_STRUCTURE, TK_UNION, and OpenDDS::XTypes::DynamicDataXcdrReadImpl::type().

 {
   const DDS::DynamicType_var type = dd->type();
   const DDS::DynamicType_var base_type = get_base_type(type);
 
   bool result;
   switch (base_type->get_kind()) {
   case TK_STRUCTURE:
   case TK_UNION:
     result = print_members(dd, type_string, indent, true);
     break;
   default:
     result = false;
   }
   return result;
 }

◆ print_member()

bool OpenDDS::XTypes::print_member	(	DDS::DynamicData_ptr	dd,
		DCPS::String &	type_string,
		DCPS::String &	indent,
		MemberId	member_id
	)

Definition at line 3002 of file DynamicDataXcdrReadImpl.cpp.

References ACE_ERROR, get_base_type(), get_enum_value(), get_enumerator_name(), get_int_value(), get_uint_value(), TAO::String_var< charT >::in(), TAO::String_var< charT >::inout(), is_complex(), is_sequence_like(), LM_NOTICE, OpenDDS::DCPS::log_level, name, OpenDDS::DCPS::LogLevel::Notice, print_members(), DDS::RETCODE_OK, OpenDDS::DCPS::string_helper(), TK_ARRAY, TK_BITMASK, TK_BITSET, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_ENUM, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_SEQUENCE, TK_STRING16, TK_STRING8, TK_STRUCTURE, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, TK_UNION, OpenDDS::DCPS::to_dds_string(), and value.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_simple_value(), and print_members().

 {
   DDS::DynamicType_ptr member_type;
   DDS::MemberDescriptor_var member_descriptor;
   const DDS::DynamicType_var container_type = dd->type();
   const DDS::TypeKind container_kind = container_type->get_kind();
   const bool sequence_like = is_sequence_like(container_kind);
   if (sequence_like) {
     DDS::TypeDescriptor_var td;
     if (container_type->get_descriptor(td) != DDS::RETCODE_OK) {
       return false;
     }
     member_type = td->element_type();
 
   } else {
     DDS::DynamicTypeMember_var dtm;
     if (container_type->get_member(dtm, member_id) != DDS::RETCODE_OK) {
       return false;
     }
     if (dtm->get_descriptor(member_descriptor) != DDS::RETCODE_OK) {
       return false;
     }
     member_type = member_descriptor->type();
   }
 
   const DDS::DynamicType_var member_base_type = get_base_type(member_type);
   const DDS::TypeKind tk = member_base_type->get_kind();
   DDS::TypeDescriptor_var member_type_descriptor;
   if (member_base_type->get_descriptor(member_type_descriptor) != DDS::RETCODE_OK) {
     return false;
   }
 
   if (member_descriptor) {
     type_string += indent;
     const bool struct_or_union = tk == TK_STRUCTURE || tk == TK_UNION;
     if (struct_or_union) {
       type_string += (tk == TK_STRUCTURE ? "struct " : "union ");
     }
     const CORBA::String_var member_type_name = member_type->get_name();
     const DCPS::String member_name = member_descriptor->name();
     type_string += DCPS::String(member_type_name.in()) + " " + member_name;
     if (!struct_or_union) {
       type_string += " ";
     }
     if (tk == TK_ARRAY || tk == TK_SEQUENCE) {
       DDS::TypeDescriptor_var td;
       const DDS::DynamicType_var elem_type = get_base_type(member_type_descriptor->element_type());
       if (elem_type->get_descriptor(td) != DDS::RETCODE_OK) {
         return false;
       }
       DCPS::String ele_type_name = td->name();
       type_string += ele_type_name;
     }
   }
 
   if (!is_complex(tk)) {
     type_string += "= ";
   }
 
   switch (tk) {
   case TK_ENUM: {
     DDS::Int32 value;
     if (get_enum_value(value, member_base_type, dd, member_id) != DDS::RETCODE_OK) {
       return false;
     }
     DDS::String8_var name;
     if (get_enumerator_name(name, value, member_base_type) == DDS::RETCODE_OK) {
        type_string += name.in();
     } else {
        type_string += DCPS::to_dds_string(value);
     }
     type_string += "\n";
     break;
   }
   case TK_INT8:
   case TK_INT16:
   case TK_INT32:
   case TK_INT64: {
     DDS::Int64 value;
     if (get_int_value(value, dd, member_id, tk) != DDS::RETCODE_OK) {
       return false;
     }
     type_string += DCPS::to_dds_string(value) + "\n";
     break;
   }
   case TK_UINT8:
   case TK_UINT16:
   case TK_UINT32:
   case TK_UINT64: {
     DDS::UInt64 value;
     if (get_uint_value(value, dd, member_id, tk) != DDS::RETCODE_OK) {
       return false;
     }
     type_string += DCPS::to_dds_string(value) + "\n";
     break;
   }
   case TK_BOOLEAN: {
     ACE_CDR::Boolean my_bool;
     if (dd->get_boolean_value(my_bool, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_boolean_value\n"));
       }
       return false;
     }
     DCPS::String bool_string = my_bool ? "true" : "false";
     type_string += bool_string + "\n";
     break;
   }
   case TK_BYTE: {
     ACE_CDR::Octet my_byte;
     if (dd->get_byte_value(my_byte, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_byte_value\n"));
       }
       return false;
     }
     std::stringstream os;
     os << std::hex << std::setfill('0') << std::setw(2) << int(my_byte);
     type_string += "0x" + os.str() + "\n";
     break;
   }
   case TK_CHAR8: {
     ACE_CDR::Char my_char;
     if (dd->get_char8_value(my_char, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_char8_value\n"));
       }
       return false;
     }
     std::stringstream os;
     DCPS::char_helper<ACE_CDR::Char>(os, my_char);
     type_string += "'" + os.str() + "'\n";
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16: {
     ACE_CDR::WChar my_wchar;
     if (dd->get_char16_value(my_wchar, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_char16_value\n"));
       }
       return false;
     }
     std::stringstream os;
     DCPS::char_helper<ACE_CDR::WChar>(os, my_wchar);
     type_string += "L'" + os.str() + "'\n";
     break;
   }
 #endif
   case TK_FLOAT32: {
     ACE_CDR::Float my_float;
     if (dd->get_float32_value(my_float, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_float32_value\n"));
       }
       return false;
     }
     std::stringstream os;
     os << my_float;
     type_string += os.str() + "\n";
     break;
   }
   case TK_FLOAT64: {
     ACE_CDR::Double my_double;
     if (dd->get_float64_value(my_double, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_float64_value\n"));
       }
       return false;
     }
     std::stringstream os;
     os << my_double;
     type_string += os.str() + "\n";
     break;
   }
   case TK_FLOAT128: {
     ACE_CDR::LongDouble my_longdouble;
     if (dd->get_float128_value(my_longdouble, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_float128_value\n"));
       }
       return false;
     }
     std::stringstream os;
     os << my_longdouble;
     type_string += os.str() + "\n";
     break;
   }
   case TK_STRING8: {
     CORBA::String_var my_string;
     if (dd->get_string_value(my_string, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_string_value\n"));
       }
       return false;
     }
     std::stringstream os;
     DCPS::string_helper(os, my_string.inout());
     type_string += DCPS::String("\"") + os.str() + "\"\n";
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16: {
     CORBA::WString_var my_wstring;
     if (dd->get_wstring_value(my_wstring, member_id) != DDS::RETCODE_OK) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: failed to get_wstring_value\n"));
       }
       return false;
     }
     std::stringstream os;
     DCPS::string_helper(os, my_wstring.inout());
     type_string += "L\"" + os.str() + "\"\n";
     break;
   }
 #endif
   case TK_BITMASK:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: Bitmask is an unsupported type in OpenDDS\n"));
     }
     break;
   case TK_BITSET:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: Bitset is an unsupported type in OpenDDS\n"));
     }
     break;
   case TK_ARRAY:
   case TK_SEQUENCE: {
     DCPS::String temp_indent = indent;
     indent += "  ";
     DDS::DynamicData_var temp_dd;
     if (dd->get_complex_value(temp_dd, member_id) != DDS::RETCODE_OK) {
       return false;
     }
     const ACE_CDR::ULong count = temp_dd->get_item_count();
     type_string += "[" + DCPS::to_dds_string(count) + "] =\n";
     for (ACE_CDR::ULong i = 0; i < count; ++i) {
       type_string += indent + "[" + DCPS::to_dds_string(i) + "] ";
       if (!print_member(temp_dd, type_string, indent, temp_dd->get_member_id_at_index(i))) {
         if (log_level >= LogLevel::Notice) {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_member: "
             "failed to read array/sequence member\n"));
         }
         return false;
       }
     }
     indent = temp_indent;
     break;
   }
   case TK_UNION:
   case TK_STRUCTURE: {
     DDS::DynamicData_var temp_dd;
     if (dd->get_complex_value(temp_dd, member_id) != DDS::RETCODE_OK) {
       return false;
     }
     if (!print_members(temp_dd, type_string, indent, sequence_like)) {
       return false;
     }
     break;
   }
   }
 
   return true;
 }

◆ print_members()

bool OpenDDS::XTypes::print_members	(	DDS::DynamicData_ptr	dd,
		DCPS::String &	type_string,
		DCPS::String &	indent,
		bool	print_name
	)

Definition at line 2964 of file DynamicDataXcdrReadImpl.cpp.

References ACE_ERROR, get_base_type(), LM_NOTICE, OpenDDS::DCPS::log_level, MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, print_member(), TK_STRUCTURE, and OpenDDS::XTypes::DynamicDataXcdrReadImpl::type().

Referenced by print_dynamic_data(), and print_member().

 {
   DCPS::String temp_indent = indent;
   indent += "  ";
   const DDS::DynamicType_var type = dd->type();
   const DDS::DynamicType_var base_type = get_base_type(type);
   const char* const kind = base_type->get_kind() == TK_STRUCTURE ? "struct" : "union";
   if (print_name) {
     CORBA::String_var type_name = type->get_name();
     type_string += DCPS::String(kind) + " " + DCPS::String(type_name);
   }
   type_string += "\n";
 
   const ACE_CDR::ULong item_count = dd->get_item_count();
   for (ACE_CDR::ULong idx = 0; idx != item_count; ++idx) {
     // Translate the item number into a MemberId.
     const MemberId member_id = dd->get_member_id_at_index(idx);
     if (member_id == MEMBER_ID_INVALID) {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_members: "
           "failed to get %C member at index %u\n", kind, idx));
       }
       return false;
     }
 
     if (!print_member(dd, type_string, indent, member_id)) {
       if (log_level >= LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: print_members: "
           "failed to print %C member with id %u\n", kind, member_id));
       }
       return false;
     }
   }
 
   indent = temp_indent;
   return true;
 }

◆ read_empty_xcdr2_nonfinal()

bool OpenDDS::XTypes::read_empty_xcdr2_nonfinal ( DCPS::Serializer & strm )

Definition at line 1114 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::read_delimiter(), and OpenDDS::DCPS::Serializer::skip().

Referenced by OpenDDS::DCPS::operator>>().

 {
   size_t total_size = 0;
   if (!strm.read_delimiter(total_size)) {
     return false;
   }
   return strm.skip(total_size);
 }

◆ serialize_type_info()

template<typename T >

void OpenDDS::XTypes::serialize_type_info	(	const TypeInformation &	type_info,
		T &	seq,
		const DCPS::Encoding *	encoding_option = `0`
	)

Definition at line 3382 of file TypeObject.h.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::encoding(), get_typeobject_encoding(), LM_ERROR, and OpenDDS::DCPS::serialized_size().

Referenced by OpenDDS::DCPS::InfoRepoDiscovery::add_publication(), OpenDDS::DCPS::InfoRepoDiscovery::add_subscription(), OpenDDS::DCPS::StaticEndpointManager::match_continue(), and OpenDDS::RTPS::Sedp::match_continue().

   {
     const DCPS::Encoding& encoding = encoding_option ? *encoding_option : get_typeobject_encoding();
     const size_t sz = DCPS::serialized_size(encoding, type_info);
     seq.length(static_cast<unsigned>(sz));
     DCPS::MessageBlockHelper<T> helper(seq);
     DCPS::Serializer serializer(helper, encoding);
     if (!(serializer << type_info)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: serialize_type_info ")
                  ACE_TEXT("serialization of type information failed.\n")));
     }
   }

◆ set_enum_value() [1/4]

DDS::ReturnCode_t OpenDDS::XTypes::set_enum_value	(	DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		DDS::Int32	value
	)

inline

Definition at line 188 of file XTypes/Utils.h.

References get_member_type(), OpenDDS_Dcps_Export, DDS::RETCODE_OK, and set_enum_value().

 {
   DDS::DynamicType_var enum_type;
   const DDS::ReturnCode_t rc = get_member_type(enum_type, dest, id);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return set_enum_value(enum_type, dest, id, value);
 }

◆ set_enum_value() [2/4]

DDS::ReturnCode_t OpenDDS::XTypes::set_enum_value	(	DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		const char *	enumeral_name
	)

inline

Definition at line 202 of file XTypes/Utils.h.

References copy(), copy_member(), get_enumerator_name(), get_enumerator_value(), get_member_type(), name, OpenDDS_Dcps_Export, OPENDDS_END_VERSIONED_NAMESPACE_DECL, DDS::RETCODE_OK, and set_enum_value().

 {
   DDS::DynamicType_var enum_type;
   const DDS::ReturnCode_t rc = get_member_type(enum_type, dest, id);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return set_enum_value(enum_type, dest, id, enumeral_name);
 }

◆ set_enum_value() [3/4]

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::set_enum_value	(	DDS::DynamicType_ptr	enum_type,
		DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		DDS::Int32	value
	)

Definition at line 1165 of file XTypes/Utils.cpp.

References enum_bound(), DDS::RETCODE_OK, and set_int_value().

Referenced by copy_member(), get_enum_value(), set_enum_value(), and OpenDDS::XTypes::DynamicDataImpl::set_string_value().

 {
   DDS::TypeKind bound_kind;
   const DDS::ReturnCode_t rc = enum_bound(enum_type, bound_kind);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return set_int_value(dest, id, bound_kind, value);
 }

◆ set_enum_value() [4/4]

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::set_enum_value	(	DDS::DynamicType_ptr	type,
		DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		const char *	enumeral_name
	)

Definition at line 1176 of file XTypes/Utils.cpp.

References ACE_ERROR, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_OK, and set_enum_value().

 {
   DDS::DynamicTypeMember_var dtm;
   DDS::ReturnCode_t rc = type->get_member_by_name(dtm, enumeral_name);
   if (rc != DDS::RETCODE_OK) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: set_enum_value: "
         "No such enumeral named \"%C\"\n",
         enumeral_name));
     }
     return rc;
   }
   DDS::MemberDescriptor_var md;
   rc = dtm->get_descriptor(md);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   return set_enum_value(type, dest, id, md->id());
 }

◆ set_int_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::set_int_value	(	DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		DDS::TypeKind	kind,
		DDS::Int64	value
	)

Definition at line 999 of file XTypes/Utils.cpp.

References DDS::RETCODE_BAD_PARAMETER, TK_INT16, TK_INT32, TK_INT64, and TK_INT8.

Referenced by copy_member(), get_member_type(), and set_enum_value().

 {
   switch (kind) {
   case TK_INT8:
     return dest->set_int8_value(id, static_cast<DDS::Int8>(value));
   case TK_INT16:
     return dest->set_int16_value(id, static_cast<DDS::Int16>(value));
   case TK_INT32:
     return dest->set_int32_value(id, static_cast<DDS::Int32>(value));
   case TK_INT64:
     return dest->set_int64_value(id, value);
   }
   return DDS::RETCODE_BAD_PARAMETER;
 }

◆ set_uint_value()

OpenDDS_Dcps_Export DDS::ReturnCode_t OpenDDS::XTypes::set_uint_value	(	DDS::DynamicData_ptr	dest,
		DDS::MemberId	id,
		DDS::TypeKind	kind,
		DDS::UInt64	value
	)

Definition at line 944 of file XTypes/Utils.cpp.

References DDS::RETCODE_BAD_PARAMETER, TK_UINT16, TK_UINT32, TK_UINT64, and TK_UINT8.

Referenced by copy_member(), and get_member_type().

 {
   switch (kind) {
   case TK_UINT8:
     return dest->set_uint8_value(id, static_cast<DDS::UInt8>(value));
   case TK_UINT16:
     return dest->set_uint16_value(id, static_cast<DDS::UInt16>(value));
   case TK_UINT32:
     return dest->set_uint32_value(id, static_cast<DDS::UInt32>(value));
   case TK_UINT64:
     return dest->set_uint64_value(id, value);
   }
   return DDS::RETCODE_BAD_PARAMETER;
 }

◆ test_equality() [1/5]

bool OpenDDS::XTypes::test_equality	(	DDS::TypeDescriptor *	lhs,
		DDS::TypeDescriptor *	rhs,
		DynamicTypePtrPairSeen &	dt_ptr_pair
	)

Definition at line 79 of file TypeDescriptorImpl.cpp.

References DDS::TypeDescriptor::base_type, DDS::TypeDescriptor::bound, DDS::TypeDescriptor::discriminator_type, DDS::TypeDescriptor::element_type, DDS::TypeDescriptor::extensibility_kind, DDS::TypeDescriptor::is_nested, DDS::TypeDescriptor::key_element_type, DDS::TypeDescriptor::kind, DDS::TypeDescriptor::name, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and test_equality().

 {
   if (lhs == rhs) {
     return true;
   }
 
   if (!lhs || !rhs) {
     return false;
   }
 
   return
     lhs->kind() == rhs->kind() &&
     std::strcmp(lhs->name(), rhs->name()) == 0 &&
     test_equality(lhs->base_type(), rhs->base_type(), dt_ptr_pair) &&
     test_equality(lhs->discriminator_type(), rhs->discriminator_type(), dt_ptr_pair) &&
     lhs->bound() == rhs->bound() &&
     test_equality(lhs->element_type(), rhs->element_type(), dt_ptr_pair) &&
     test_equality(lhs->key_element_type(), rhs->key_element_type(), dt_ptr_pair) &&
     lhs->extensibility_kind() == rhs->extensibility_kind() &&
     lhs->is_nested() == rhs->is_nested();
 }

◆ test_equality() [2/5]

bool OpenDDS::XTypes::test_equality	(	DDS::MemberDescriptor *	lhs,
		DDS::MemberDescriptor *	rhs,
		DynamicTypePtrPairSeen &	dt_ptr_pair
	)

Definition at line 84 of file MemberDescriptorImpl.cpp.

References DDS::MemberDescriptor::default_value, DDS::MemberDescriptor::id, DDS::MemberDescriptor::index, DDS::MemberDescriptor::is_default_label, DDS::MemberDescriptor::is_key, DDS::MemberDescriptor::is_must_understand, DDS::MemberDescriptor::is_optional, DDS::MemberDescriptor::is_shared, DDS::MemberDescriptor::label, DDS::MemberDescriptor::name, OPENDDS_END_VERSIONED_NAMESPACE_DECL, test_equality(), DDS::MemberDescriptor::try_construct_kind, and DDS::MemberDescriptor::type.

 {
   const DDS::DynamicType_ptr lhs_type = lhs->type();
   const DDS::DynamicType_ptr rhs_type = rhs->type();
   return
     std::strcmp(lhs->name(), rhs->name()) == 0 &&
     lhs->id() == rhs->id() &&
     test_equality(lhs_type, rhs_type, dt_ptr_pair) &&
     lhs->default_value() == rhs->default_value() &&
     lhs->index() == rhs->index() &&
     lhs->label() == rhs->label() &&
     lhs->try_construct_kind() == rhs->try_construct_kind() &&
     lhs->is_key() == rhs->is_key() &&
     lhs->is_optional() == rhs->is_optional() &&
     lhs->is_must_understand() == rhs->is_must_understand() &&
     lhs->is_shared() == rhs->is_shared() &&
     lhs->is_default_label() == rhs->is_default_label();
 }

◆ test_equality() [3/5]

bool OpenDDS::XTypes::test_equality	(	DDS::DynamicType_ptr	lhs,
		DDS::DynamicType_ptr	rhs,
		DynamicTypePtrPairSeen &	dt_ptr_pair
	)

Definition at line 196 of file DynamicTypeImpl.cpp.

References OPENDDS_ASSERT, and DDS::RETCODE_OK.

Referenced by OpenDDS::XTypes::DynamicTypeMemberImpl::equals(), OpenDDS::XTypes::TypeDescriptorImpl::equals(), OpenDDS::XTypes::MemberDescriptorImpl::equals(), OpenDDS::XTypes::DynamicTypeImpl::equals(), and test_equality().

 {
   if (lhs == rhs) {
     return true;
   }
 
   OPENDDS_ASSERT(lhs);
   OPENDDS_ASSERT(rhs);
 
   if (lhs == 0 || rhs == 0) {
     return false;
   }
 
   const DynamicTypePtrPair this_pair = std::make_pair(lhs, rhs);
   DynamicTypePtrPairSeen::const_iterator have_seen = dt_ptr_pair.find(this_pair);
   if (have_seen == dt_ptr_pair.end()) {
     dt_ptr_pair.insert(this_pair);
 
     DDS::TypeDescriptor_var lhs_descriptor;
     DDS::TypeDescriptor_var rhs_descriptor;
     DDS::DynamicTypeMembersByName_var lhs_members_by_name;
     DDS::DynamicTypeMembersByName_var rhs_members_by_name;
     DDS::DynamicTypeMembersById_var lhs_members_by_id;
     DDS::DynamicTypeMembersById_var rhs_members_by_id;
 
     if (lhs->get_descriptor(lhs_descriptor) != DDS::RETCODE_OK ||
         rhs->get_descriptor(rhs_descriptor) != DDS::RETCODE_OK ||
         lhs->get_all_members_by_name(lhs_members_by_name) != DDS::RETCODE_OK ||
         rhs->get_all_members_by_name(rhs_members_by_name) != DDS::RETCODE_OK ||
         lhs->get_all_members(lhs_members_by_id) != DDS::RETCODE_OK ||
         rhs->get_all_members(rhs_members_by_id) != DDS::RETCODE_OK) {
       return false;
     }
 
     return
       test_equality(lhs_descriptor, rhs_descriptor, dt_ptr_pair) &&
       test_equality(dynamic_cast<DynamicTypeMembersByNameImpl*>(lhs_members_by_name.in()),
                     dynamic_cast<DynamicTypeMembersByNameImpl*>(rhs_members_by_name.in()), dt_ptr_pair) &&
       test_equality(dynamic_cast<DynamicTypeMembersByIdImpl*>(lhs_members_by_id.in()),
                     dynamic_cast<DynamicTypeMembersByIdImpl*>(rhs_members_by_id.in()), dt_ptr_pair);
   }
 
   return true;
 }

◆ test_equality() [4/5]

bool OpenDDS::XTypes::test_equality	(	DynamicTypeMembersByNameImpl *	lhs,
		DynamicTypeMembersByNameImpl *	rhs,
		DynamicTypePtrPairSeen &	dt_ptr_pair
	)

Definition at line 241 of file DynamicTypeImpl.cpp.

References OpenDDS::XTypes::DynamicTypeMembersByNameImpl::begin(), OpenDDS::XTypes::DynamicTypeMembersByNameImpl::end(), OpenDDS::XTypes::DynamicTypeMembersByNameImpl::find(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicTypeMembersByNameImpl::size(), and test_equality().

 {
   if (lhs == rhs) {
     return true;
   }
 
   if (lhs == 0 || rhs == 0) {
     return false;
   }
 
   if (lhs->size() != rhs->size()) {
     return false;
   }
 
   for (DynamicTypeMembersByNameImpl::const_iterator lhs_it = lhs->begin(); lhs_it != lhs->end(); ++lhs_it) {
     const DynamicTypeMembersByNameImpl::const_iterator rhs_it = rhs->find(lhs_it->first);
     if (rhs_it == rhs->end()) {
       return false;
     }
     DDS::MemberDescriptor_var lhs_md;
     DDS::MemberDescriptor_var rhs_md;
     if (lhs_it->second->get_descriptor(lhs_md) != DDS::RETCODE_OK ||
         rhs_it->second->get_descriptor(rhs_md) != DDS::RETCODE_OK) {
       return false;
     }
     if (!test_equality(lhs_md, rhs_md, dt_ptr_pair)) {
       return false;
     }
   }
   return true;
 }

◆ test_equality() [5/5]

bool OpenDDS::XTypes::test_equality	(	DynamicTypeMembersByIdImpl *	lhs,
		DynamicTypeMembersByIdImpl *	rhs,
		DynamicTypePtrPairSeen &	dt_ptr_pair
	)

Definition at line 273 of file DynamicTypeImpl.cpp.

References OpenDDS::XTypes::DynamicTypeMembersByIdImpl::begin(), OpenDDS::XTypes::DynamicTypeMembersByIdImpl::end(), OpenDDS::XTypes::DynamicTypeMembersByIdImpl::find(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicTypeMembersByIdImpl::size(), and test_equality().

 {
   if (lhs == rhs) {
     return true;
   }
 
   if (lhs == 0 || rhs == 0) {
     return false;
   }
 
   if (lhs->size() != rhs->size()) {
     return false;
   }
 
   for (DynamicTypeMembersByIdImpl::const_iterator lhs_it = lhs->begin(); lhs_it != lhs->end(); ++lhs_it) {
     const DynamicTypeMembersByIdImpl::const_iterator rhs_it = rhs->find(lhs_it->first);
     if (rhs_it == rhs->end()) {
       return false;
     }
     DDS::MemberDescriptor_var lhs_md;
     DDS::MemberDescriptor_var rhs_md;
     if (lhs_it->second->get_descriptor(lhs_md) != DDS::RETCODE_OK ||
         rhs_it->second->get_descriptor(rhs_md) != DDS::RETCODE_OK) {
       return false;
     }
     if (!test_equality(lhs_md, rhs_md, dt_ptr_pair)) {
       return false;
     }
   }
   return true;
 }

◆ typekind_to_string()

OpenDDS_Dcps_Export const char * OpenDDS::XTypes::typekind_to_string ( TypeKind tk )

Definition at line 1123 of file TypeObject.cpp.

References ACE_ERROR, LM_WARNING, OpenDDS::DCPS::log_level, TK_ALIAS, TK_ANNOTATION, TK_ARRAY, TK_BITMASK, TK_BITSET, TK_BOOLEAN, TK_BYTE, TK_CHAR16, TK_CHAR8, TK_ENUM, TK_FLOAT128, TK_FLOAT32, TK_FLOAT64, TK_INT16, TK_INT32, TK_INT64, TK_INT8, TK_MAP, TK_NONE, TK_SEQUENCE, TK_STRING16, TK_STRING8, TK_STRUCTURE, TK_UINT16, TK_UINT32, TK_UINT64, TK_UINT8, TK_UNION, and OpenDDS::DCPS::LogLevel::Warning.

 {
   switch (tk) {
   case TK_NONE:
     return "none";
   case TK_BOOLEAN:
     return "boolean";
   case TK_BYTE:
     return "byte";
   case TK_INT16:
     return "int16";
   case TK_INT32:
     return "int32";
   case TK_INT64:
     return "int64";
   case TK_UINT16:
     return "uint16";
   case TK_UINT32:
     return "uint32";
   case TK_UINT64:
     return "uint64";
   case TK_FLOAT32:
     return "float32";
   case TK_FLOAT64:
     return "float64";
   case TK_FLOAT128:
     return "float128";
   case TK_INT8:
     return "int8";
   case TK_UINT8:
     return "uint8";
   case TK_CHAR8:
     return "char8";
   case TK_CHAR16:
     return "char16";
   case TK_STRING8:
     return "string";
   case TK_STRING16:
     return "wstring";
   case TK_ALIAS:
     return "alias";
   case TK_ENUM:
     return "enum";
   case TK_BITMASK:
     return "bitmask";
   case TK_ANNOTATION:
     return "annotation";
   case TK_STRUCTURE:
     return "structure";
   case TK_UNION:
     return "union";
   case TK_BITSET:
     return "bitset";
   case TK_SEQUENCE:
     return "sequence";
   case TK_ARRAY:
     return "array";
   case TK_MAP:
     return "map";
   default:
     if (DCPS::log_level >= DCPS::LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: typekind_to_string: "
         "passed unknown TypeKind %u\n", tk));
     }
     return "unknown";
   }
 }

◆ write_empty_xcdr2_nonfinal()

bool OpenDDS::XTypes::write_empty_xcdr2_nonfinal ( DCPS::Serializer & strm )

Definition at line 1107 of file TypeObject.cpp.

References OpenDDS::DCPS::Serializer::encoding(), OpenDDS::DCPS::serialized_size_delimiter(), and OpenDDS::DCPS::Serializer::write_delimiter().

Referenced by OpenDDS::DCPS::operator<<().

 {
   size_t size = 0;
   serialized_size_delimiter(strm.encoding(), size);
   return strm.write_delimiter(size);
 }

Variable Documentation

◆ ANNOTATION_OCTETSEC_VALUE_MAX_LEN

const ACE_CDR::ULong OpenDDS::XTypes::ANNOTATION_OCTETSEC_VALUE_MAX_LEN = 128

Definition at line 915 of file TypeObject.h.

◆ ANNOTATION_STR_VALUE_MAX_LEN

const ACE_CDR::ULong OpenDDS::XTypes::ANNOTATION_STR_VALUE_MAX_LEN = 128

Definition at line 914 of file TypeObject.h.

◆ DDS_RETCODE_OK

const long OpenDDS::XTypes::DDS_RETCODE_OK = 0

Definition at line 18 of file TypeLookup.idl.

◆ DISCRIMINATOR_ID

const ACE_CDR::ULong OpenDDS::XTypes::DISCRIMINATOR_ID = MEMBER_ID_INVALID - 1

Implementation specific sentinel for a union discriminator used in DynamicData.

Definition at line 913 of file TypeObject.h.

◆ EK_BOTH

const EquivalenceKind OpenDDS::XTypes::EK_BOTH = 0xF3

Definition at line 207 of file TypeObject.h.

Referenced by typeobject_generator::generate_array_type_identifier(), typeobject_generator::generate_sequence_type_identifier(), and is_fully_descriptive().

◆ EK_COMPLETE

const EquivalenceKind OpenDDS::XTypes::EK_COMPLETE = 0xF2

Definition at line 206 of file TypeObject.h.

◆ EK_MINIMAL

const EquivalenceKind OpenDDS::XTypes::EK_MINIMAL = 0xF1

Definition at line 205 of file TypeObject.h.

◆ INVALID_LBOUND

const LBound OpenDDS::XTypes::INVALID_LBOUND = 0

Definition at line 314 of file TypeObject.h.

◆ INVALID_SBOUND

const SBound OpenDDS::XTypes::INVALID_SBOUND = 0

Definition at line 319 of file TypeObject.h.

◆ IS_APPENDABLE

const TypeFlag OpenDDS::XTypes::IS_APPENDABLE = 1 << 1

Definition at line 401 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_enum(), OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeLookupService::complete_to_dynamic(), OpenDDS::DCPS::StaticEndpointManager::match_continue(), OpenDDS::RTPS::Sedp::match_continue(), and OpenDDS::XTypes::TypeLookupService::set_type_object_defaults().

◆ IS_AUTOID_HASH

const TypeFlag OpenDDS::XTypes::IS_AUTOID_HASH = 1 << 4

Definition at line 405 of file TypeObject.h.

Referenced by typeobject_generator::generate_struct_type_identifier(), and typeobject_generator::generate_union_type_identifier().

◆ IS_DEFAULT

const MemberFlag OpenDDS::XTypes::IS_DEFAULT = 1 << 6

Definition at line 376 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeLookupService::complete_to_dynamic_i(), OpenDDS::XTypes::TypeLookupService::complete_union_member_to_member_descriptor(), typeobject_generator::generate_enum_type_identifier(), and typeobject_generator::generate_union_type_identifier().

◆ IS_EXTERNAL

const MemberFlag OpenDDS::XTypes::IS_EXTERNAL = 1 << 2

Definition at line 371 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeLookupService::complete_struct_member_to_member_descriptor(), OpenDDS::XTypes::TypeLookupService::complete_union_member_to_member_descriptor(), typeobject_generator::generate_array_type_identifier(), typeobject_generator::generate_sequence_type_identifier(), typeobject_generator::generate_struct_type_identifier(), and typeobject_generator::generate_union_type_identifier().

◆ IS_FINAL

const TypeFlag OpenDDS::XTypes::IS_FINAL = 1 << 0

Definition at line 400 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_enum(), OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeAssignability::is_delimited_with_flags(), and OpenDDS::XTypes::TypeLookupService::set_type_object_defaults().

◆ IS_KEY

const MemberFlag OpenDDS::XTypes::IS_KEY = 1 << 5

Definition at line 375 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeLookupService::complete_struct_member_to_member_descriptor(), OpenDDS::XTypes::TypeLookupService::complete_to_dynamic_i(), OpenDDS::XTypes::TypeAssignability::erase_key(), typeobject_generator::generate_struct_type_identifier(), typeobject_generator::generate_union_type_identifier(), and OpenDDS::XTypes::TypeAssignability::hold_key().

◆ IS_MUST_UNDERSTAND

const MemberFlag OpenDDS::XTypes::IS_MUST_UNDERSTAND = 1 << 4

Definition at line 374 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeLookupService::complete_struct_member_to_member_descriptor(), and typeobject_generator::generate_struct_type_identifier().

◆ IS_MUTABLE

const TypeFlag OpenDDS::XTypes::IS_MUTABLE = 1 << 2

Definition at line 402 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_enum(), OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeAssignability::assignable_union(), OpenDDS::XTypes::TypeLookupService::complete_to_dynamic(), OpenDDS::XTypes::TypeAssignability::is_delimited_with_flags(), and OpenDDS::XTypes::TypeLookupService::set_type_object_defaults().

◆ IS_NESTED

const TypeFlag OpenDDS::XTypes::IS_NESTED = 1 << 3

Definition at line 404 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeLookupService::complete_to_dynamic_i(), typeobject_generator::generate_struct_type_identifier(), and typeobject_generator::generate_union_type_identifier().

◆ IS_OPTIONAL

const MemberFlag OpenDDS::XTypes::IS_OPTIONAL = 1 << 3

Definition at line 373 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeAssignability::assignable_struct(), OpenDDS::XTypes::TypeLookupService::complete_struct_member_to_member_descriptor(), and typeobject_generator::generate_struct_type_identifier().

◆ MEMBER_ID_INVALID

const ACE_CDR::ULong OpenDDS::XTypes::MEMBER_ID_INVALID = ACE_UINT32_MAX

Definition at line 911 of file TypeObject.h.

◆ MEMBER_NAME_MAX_LENGTH

const ACE_CDR::Long OpenDDS::XTypes::MEMBER_NAME_MAX_LENGTH = 256

Definition at line 274 of file TypeObject.h.

Referenced by is_sequence_like(), OpenDDS::DCPS::operator<<(), and OpenDDS::DCPS::operator>>().

◆ MemberFlagMinimalMask

const MemberFlag OpenDDS::XTypes::MemberFlagMinimalMask = 0x003f

Definition at line 394 of file TypeObject.h.

◆ TI_PLAIN_ARRAY_LARGE

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_ARRAY_LARGE = 0x91

Definition at line 264 of file TypeObject.h.

◆ TI_PLAIN_ARRAY_SMALL

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_ARRAY_SMALL = 0x90

Definition at line 263 of file TypeObject.h.

◆ TI_PLAIN_MAP_LARGE

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_MAP_LARGE = 0xA1

Definition at line 267 of file TypeObject.h.

◆ TI_PLAIN_MAP_SMALL

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_MAP_SMALL = 0xA0

Definition at line 266 of file TypeObject.h.

◆ TI_PLAIN_SEQUENCE_LARGE

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_SEQUENCE_LARGE = 0x81

Definition at line 261 of file TypeObject.h.

◆ TI_PLAIN_SEQUENCE_SMALL

const TypeIdentifierKind OpenDDS::XTypes::TI_PLAIN_SEQUENCE_SMALL = 0x80

Definition at line 260 of file TypeObject.h.

◆ TI_STRING16_LARGE

const TypeIdentifierKind OpenDDS::XTypes::TI_STRING16_LARGE = 0x73

Definition at line 258 of file TypeObject.h.

◆ TI_STRING16_SMALL

const TypeIdentifierKind OpenDDS::XTypes::TI_STRING16_SMALL = 0x72

Definition at line 257 of file TypeObject.h.

◆ TI_STRING8_LARGE

const TypeIdentifierKind OpenDDS::XTypes::TI_STRING8_LARGE = 0x71

Definition at line 256 of file TypeObject.h.

◆ TI_STRING8_SMALL

const TypeIdentifierKind OpenDDS::XTypes::TI_STRING8_SMALL = 0x70

Definition at line 255 of file TypeObject.h.

◆ TI_STRONGLY_CONNECTED_COMPONENT

const TypeIdentifierKind OpenDDS::XTypes::TI_STRONGLY_CONNECTED_COMPONENT = 0xB0

Definition at line 269 of file TypeObject.h.

◆ TK_ALIAS

const TypeKind OpenDDS::XTypes::TK_ALIAS = 0x30

Definition at line 235 of file TypeObject.h.

◆ TK_ANNOTATION

const TypeKind OpenDDS::XTypes::TK_ANNOTATION = 0x50

Definition at line 242 of file TypeObject.h.

◆ TK_ARRAY

const TypeKind OpenDDS::XTypes::TK_ARRAY = 0x61

Definition at line 249 of file TypeObject.h.

◆ TK_BITMASK

const TypeKind OpenDDS::XTypes::TK_BITMASK = 0x41

Definition at line 239 of file TypeObject.h.

◆ TK_BITSET

const TypeKind OpenDDS::XTypes::TK_BITSET = 0x53

Definition at line 245 of file TypeObject.h.

◆ TK_BOOLEAN

const TypeKind OpenDDS::XTypes::TK_BOOLEAN = 0x01

Definition at line 214 of file TypeObject.h.

◆ TK_BYTE

const TypeKind OpenDDS::XTypes::TK_BYTE = 0x02

Definition at line 215 of file TypeObject.h.

◆ TK_CHAR16

const TypeKind OpenDDS::XTypes::TK_CHAR16 = 0x11

Definition at line 228 of file TypeObject.h.

◆ TK_CHAR8

const TypeKind OpenDDS::XTypes::TK_CHAR8 = 0x10

Definition at line 227 of file TypeObject.h.

◆ TK_ENUM

const TypeKind OpenDDS::XTypes::TK_ENUM = 0x40

Definition at line 238 of file TypeObject.h.

◆ TK_FLOAT128

const TypeKind OpenDDS::XTypes::TK_FLOAT128 = 0x0B

Definition at line 224 of file TypeObject.h.

◆ TK_FLOAT32

const TypeKind OpenDDS::XTypes::TK_FLOAT32 = 0x09

Definition at line 222 of file TypeObject.h.

◆ TK_FLOAT64

const TypeKind OpenDDS::XTypes::TK_FLOAT64 = 0x0A

Definition at line 223 of file TypeObject.h.

◆ TK_INT16

const TypeKind OpenDDS::XTypes::TK_INT16 = 0x03

Definition at line 216 of file TypeObject.h.

◆ TK_INT32

const TypeKind OpenDDS::XTypes::TK_INT32 = 0x04

Definition at line 217 of file TypeObject.h.

◆ TK_INT64

const TypeKind OpenDDS::XTypes::TK_INT64 = 0x05

Definition at line 218 of file TypeObject.h.

◆ TK_INT8

const TypeKind OpenDDS::XTypes::TK_INT8 = 0x0C

Definition at line 225 of file TypeObject.h.

◆ TK_MAP

const TypeKind OpenDDS::XTypes::TK_MAP = 0x62

Definition at line 250 of file TypeObject.h.

◆ TK_NONE

const TypeKind OpenDDS::XTypes::TK_NONE = 0x00

Definition at line 213 of file TypeObject.h.

◆ TK_SEQUENCE

const TypeKind OpenDDS::XTypes::TK_SEQUENCE = 0x60

Definition at line 248 of file TypeObject.h.

◆ TK_STRING16

const TypeKind OpenDDS::XTypes::TK_STRING16 = 0x21

Definition at line 232 of file TypeObject.h.

◆ TK_STRING8

const TypeKind OpenDDS::XTypes::TK_STRING8 = 0x20

Definition at line 231 of file TypeObject.h.

◆ TK_STRUCTURE

const TypeKind OpenDDS::XTypes::TK_STRUCTURE = 0x51

Definition at line 243 of file TypeObject.h.

◆ TK_UINT16

const TypeKind OpenDDS::XTypes::TK_UINT16 = 0x06

Definition at line 219 of file TypeObject.h.

◆ TK_UINT32

const TypeKind OpenDDS::XTypes::TK_UINT32 = 0x07

Definition at line 220 of file TypeObject.h.

◆ TK_UINT64

const TypeKind OpenDDS::XTypes::TK_UINT64 = 0x08

Definition at line 221 of file TypeObject.h.

◆ TK_UINT8

const TypeKind OpenDDS::XTypes::TK_UINT8 = 0x0D

Definition at line 226 of file TypeObject.h.

◆ TK_UNION

const TypeKind OpenDDS::XTypes::TK_UNION = 0x52

Definition at line 244 of file TypeObject.h.

◆ TRY_CONSTRUCT1

const MemberFlag OpenDDS::XTypes::TRY_CONSTRUCT1 = 1 << 0

Definition at line 369 of file TypeObject.h.

Referenced by OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::handle_tryconstruct_flags().

◆ TRY_CONSTRUCT2

const MemberFlag OpenDDS::XTypes::TRY_CONSTRUCT2 = 1 << 1

Definition at line 370 of file TypeObject.h.

Referenced by OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::handle_tryconstruct_flags().

◆ TryConstructDiscardValue

const MemberFlag OpenDDS::XTypes::TryConstructDiscardValue = TRY_CONSTRUCT1

Definition at line 388 of file TypeObject.h.

◆ TryConstructTrimValue

const MemberFlag OpenDDS::XTypes::TryConstructTrimValue = TRY_CONSTRUCT1 | TRY_CONSTRUCT2

Definition at line 390 of file TypeObject.h.

◆ TryConstructUseDefaultValue

const MemberFlag OpenDDS::XTypes::TryConstructUseDefaultValue = TRY_CONSTRUCT2

Definition at line 389 of file TypeObject.h.

◆ TYPE_NAME_MAX_LENGTH

const ACE_CDR::Long OpenDDS::XTypes::TYPE_NAME_MAX_LENGTH = 256

Definition at line 279 of file TypeObject.h.

Referenced by is_sequence_like(), OpenDDS::DCPS::operator<<(), and OpenDDS::DCPS::operator>>().

◆ TypeFlagMinimalMask

const TypeFlag OpenDDS::XTypes::TypeFlagMinimalMask = 0x0007

Definition at line 417 of file TypeObject.h.

Referenced by OpenDDS::XTypes::TypeLookupService::complete_to_dynamic_i(), and OpenDDS::XTypes::TypeLookupService::set_type_object_defaults().

◆ TypeLookup_getDependencies_HashId

const long OpenDDS::XTypes::TypeLookup_getDependencies_HashId = 0x05aafb31

Definition at line 27 of file TypeLookup.idl.

Referenced by OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply(), OpenDDS::RTPS::Sedp::TypeLookupRequestReader::process_type_lookup_request(), OpenDDS::RTPS::Sedp::send_type_lookup_request(), and OpenDDS::RTPS::Sedp::TypeLookupRequestWriter::send_type_lookup_request().

◆ TypeLookup_getTypes_HashId

const long OpenDDS::XTypes::TypeLookup_getTypes_HashId = 0x018252d3

Definition at line 26 of file TypeLookup.idl.

Referenced by OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply(), OpenDDS::RTPS::Sedp::TypeLookupRequestReader::process_type_lookup_request(), OpenDDS::RTPS::Sedp::send_type_lookup_request(), and OpenDDS::RTPS::Sedp::TypeLookupRequestWriter::send_type_lookup_request().

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AliasMemberFlag

◆ AliasTypeFlag

◆ AnnotationParameterFlag

◆ AnnotationTypeFlag

◆ AppliedAnnotationParameterSeq

◆ AppliedAnnotationSeq

◆ BitBound

◆ BitflagFlag

◆ BitmaskTypeFlag

◆ BitsetMemberFlag

◆ BitsetTypeFlag

◆ CollectionElementFlag

◆ CollectionTypeFlag

◆ CompleteAnnotationParameterSeq

◆ CompleteBitfieldSeq

◆ CompleteBitflagSeq

◆ CompleteBitmaskHeader

◆ CompleteEnumeratedLiteralSeq

◆ CompleteStructMemberSeq

◆ CompleteUnionMemberSeq

◆ DynamicTypePtrPair

◆ EnumeratedLiteralFlag

◆ EnumTypeFlag

◆ EquivalenceHash

◆ EquivalenceHash_forany

◆ EquivalenceHash_slice

◆ EquivalenceKind

◆ LBound

◆ LBoundSeq

◆ MemberFlag

◆ MemberId

◆ MemberName

◆ MemberPair

◆ MinimalAnnotationParameterSeq

◆ MinimalBitfieldSeq

◆ MinimalBitflagSeq

◆ MinimalBitmaskHeader

◆ MinimalEnumeratedLiteralSeq

◆ MinimalStructMemberSeq

◆ MinimalUnionMemberSeq

◆ NameHash

◆ NameHash_forany

◆ NameHash_slice

◆ OctetSeq32

◆ PrimitiveTypeId

◆ QualifiedTypeName

◆ SBound

◆ SBoundSeq

◆ StronglyConnectedComponent

◆ StructMemberFlag

◆ StructTypeFlag

◆ TypeFlag

◆ TypeIdentifierKind

◆ TypeIdentifierPairSeq

◆ TypeIdentifierSeq

◆ TypeIdentifierTypeObjectPairSeq

◆ TypeIdentifierWithDependenciesSeq

◆ TypeIdentifierWithSizeSeq

◆ TypeKind

◆ TypeLookupService_rch

◆ TypeObjectSeq

◆ UnionCaseLabelSeq

◆ UnionDiscriminatorFlag

◆ UnionMemberFlag

◆ UnionTypeFlag

Enumeration Type Documentation

◆ Filter

Function Documentation

◆ bitmask_bound()

◆ bound_total()

◆ compare_members()

◆ compute_dependencies()

◆ copy()

◆ copy_member()