#include <DynamicDataImpl.h>

Inheritance diagram for OpenDDS::XTypes::DynamicDataImpl:

[legend]

Collaboration diagram for OpenDDS::XTypes::DynamicDataImpl:

[legend]

Classes
struct	DataContainer

struct	SequenceValue

struct	SingleValue

Public Member Functions
	DynamicDataImpl (DDS::DynamicType_ptr type)

	DynamicDataImpl (const DynamicDataImpl &other)

DDS::DynamicType_ptr	type ()

DDS::ReturnCode_t	set_descriptor (MemberId id, DDS::MemberDescriptor *value)

CORBA::Boolean	equals (DDS::DynamicData_ptr other)

MemberId	get_member_id_at_index (ACE_CDR::ULong index)

ACE_CDR::ULong	get_item_count ()

DDS::ReturnCode_t	clear_all_values ()

DDS::ReturnCode_t	clear_nonkey_values ()

DDS::ReturnCode_t	clear_value (DDS::MemberId id)

DDS::DynamicData_ptr	loan_value (DDS::MemberId id)

DDS::ReturnCode_t	return_loaned_value (DDS::DynamicData_ptr value)

DDS::DynamicData_ptr	clone ()

DDS::ReturnCode_t	get_int8_value (CORBA::Int8 &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int8_value (DDS::MemberId id, CORBA::Int8 value)

DDS::ReturnCode_t	get_uint8_value (CORBA::UInt8 &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint8_value (DDS::MemberId id, CORBA::UInt8 value)

DDS::ReturnCode_t	get_int16_value (CORBA::Short &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int16_value (DDS::MemberId id, CORBA::Short value)

DDS::ReturnCode_t	get_uint16_value (CORBA::UShort &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint16_value (DDS::MemberId id, CORBA::UShort value)

DDS::ReturnCode_t	get_int32_value (CORBA::Long &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int32_value (DDS::MemberId id, CORBA::Long value)

DDS::ReturnCode_t	get_uint32_value (CORBA::ULong &value, DDS::MemberId)

DDS::ReturnCode_t	set_uint32_value (DDS::MemberId id, CORBA::ULong value)

DDS::ReturnCode_t	get_int64_value (CORBA::LongLong &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int64_value (DDS::MemberId id, CORBA::LongLong value)

DDS::ReturnCode_t	get_uint64_value (CORBA::ULongLong &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint64_value (DDS::MemberId id, CORBA::ULongLong value)

DDS::ReturnCode_t	get_float32_value (CORBA::Float &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float32_value (DDS::MemberId id, CORBA::Float value)

DDS::ReturnCode_t	get_float64_value (CORBA::Double &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float64_value (DDS::MemberId id, CORBA::Double value)

DDS::ReturnCode_t	get_float128_value (CORBA::LongDouble &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float128_value (DDS::MemberId id, CORBA::LongDouble value)

DDS::ReturnCode_t	get_char8_value (CORBA::Char &value, DDS::MemberId id)

DDS::ReturnCode_t	set_char8_value (DDS::MemberId id, CORBA::Char value)

DDS::ReturnCode_t	get_char16_value (CORBA::WChar &value, DDS::MemberId id)

DDS::ReturnCode_t	set_char16_value (DDS::MemberId id, CORBA::WChar value)

DDS::ReturnCode_t	get_byte_value (CORBA::Octet &value, DDS::MemberId id)

DDS::ReturnCode_t	set_byte_value (DDS::MemberId id, CORBA::Octet value)

DDS::ReturnCode_t	get_boolean_value (CORBA::Boolean &value, DDS::MemberId id)

DDS::ReturnCode_t	set_boolean_value (DDS::MemberId id, CORBA::Boolean value)

DDS::ReturnCode_t	get_string_value (char *&value, DDS::MemberId id)

DDS::ReturnCode_t	set_string_value (DDS::MemberId id, const char *value)

DDS::ReturnCode_t	get_wstring_value (CORBA::WChar *&value, DDS::MemberId id)

DDS::ReturnCode_t	set_wstring_value (DDS::MemberId id, const CORBA::WChar *value)

DDS::ReturnCode_t	get_complex_value (DDS::DynamicData_ptr &value, DDS::MemberId id)

DDS::ReturnCode_t	set_complex_value (DDS::MemberId id, DDS::DynamicData_ptr value)

DDS::ReturnCode_t	get_int32_values (DDS::Int32Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int32_values (DDS::MemberId id, const DDS::Int32Seq &value)

DDS::ReturnCode_t	get_uint32_values (DDS::UInt32Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint32_values (DDS::MemberId id, const DDS::UInt32Seq &value)

DDS::ReturnCode_t	get_int8_values (DDS::Int8Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int8_values (DDS::MemberId id, const DDS::Int8Seq &value)

DDS::ReturnCode_t	get_uint8_values (DDS::UInt8Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint8_values (DDS::MemberId id, const DDS::UInt8Seq &value)

DDS::ReturnCode_t	get_int16_values (DDS::Int16Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int16_values (DDS::MemberId id, const DDS::Int16Seq &value)

DDS::ReturnCode_t	get_uint16_values (DDS::UInt16Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint16_values (DDS::MemberId id, const DDS::UInt16Seq &value)

DDS::ReturnCode_t	get_int64_values (DDS::Int64Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_int64_values (DDS::MemberId id, const DDS::Int64Seq &value)

DDS::ReturnCode_t	get_uint64_values (DDS::UInt64Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_uint64_values (DDS::MemberId id, const DDS::UInt64Seq &value)

DDS::ReturnCode_t	get_float32_values (DDS::Float32Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float32_values (DDS::MemberId id, const DDS::Float32Seq &value)

DDS::ReturnCode_t	get_float64_values (DDS::Float64Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float64_values (DDS::MemberId id, const DDS::Float64Seq &value)

DDS::ReturnCode_t	get_float128_values (DDS::Float128Seq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_float128_values (DDS::MemberId id, const DDS::Float128Seq &value)

DDS::ReturnCode_t	get_char8_values (DDS::CharSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_char8_values (DDS::MemberId id, const DDS::CharSeq &value)

DDS::ReturnCode_t	get_char16_values (DDS::WcharSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_char16_values (DDS::MemberId id, const DDS::WcharSeq &value)

DDS::ReturnCode_t	get_byte_values (DDS::ByteSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_byte_values (DDS::MemberId id, const DDS::ByteSeq &value)

DDS::ReturnCode_t	get_boolean_values (DDS::BooleanSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_boolean_values (DDS::MemberId id, const DDS::BooleanSeq &value)

DDS::ReturnCode_t	get_string_values (DDS::StringSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_string_values (DDS::MemberId id, const DDS::StringSeq &value)

DDS::ReturnCode_t	get_wstring_values (DDS::WstringSeq &value, DDS::MemberId id)

DDS::ReturnCode_t	set_wstring_values (DDS::MemberId id, const DDS::WstringSeq &value)

DDS::ReturnCode_t	get_simple_value (DCPS::Value &value, DDS::MemberId id)

template<>
bool	read_basic_in_single_map (char *&value, DDS::MemberId id)

template<>
bool	read_basic_in_single_map (CORBA::WChar *&value, DDS::MemberId id)

template<>
bool	read_basic_member (char *&value, DDS::MemberId id)

template<>
bool	read_basic_member (CORBA::WChar *&value, DDS::MemberId id)

template<>
bool	get_value_from_self (char *&, DDS::MemberId)

template<>
bool	get_value_from_self (CORBA::WChar *&, DDS::MemberId)

Public Member Functions inherited from OpenDDS::XTypes::DynamicDataBase
	DynamicDataBase ()

	DynamicDataBase (DDS::DynamicType_ptr type)

DDS::ReturnCode_t	get_descriptor (DDS::MemberDescriptor *&value, MemberId id)

DDS::MemberId	get_member_id_by_name (const char *name)

Public Member Functions inherited from DDS::DynamicData
DDS::ReturnCode_t	get_descriptor (inout MemberDescriptor value, in MemberId id)

DDS::ReturnCode_t	set_descriptor (in MemberId id, in MemberDescriptor value)

boolean	equals (in DynamicData other)

MemberId	get_member_id_by_name (in ObjectName name)

MemberId	get_member_id_at_index (in unsigned long index)

DDS::ReturnCode_t	clear_value (in MemberId id)

DynamicData	loan_value (in MemberId id)

DDS::ReturnCode_t	return_loaned_value (in DynamicData value)

DDS::ReturnCode_t	get_int32_value (inout long value, in MemberId id)

DDS::ReturnCode_t	set_int32_value (in MemberId id, in long value)

DDS::ReturnCode_t	get_uint32_value (inout unsigned long value, in MemberId id)

DDS::ReturnCode_t	set_uint32_value (in MemberId id, in unsigned long value)

DDS::ReturnCode_t	get_int8_value (inout int8 value, in MemberId id)

DDS::ReturnCode_t	set_int8_value (in MemberId id, in int8 value)

DDS::ReturnCode_t	get_uint8_value (inout uint8 value, in MemberId id)

DDS::ReturnCode_t	set_uint8_value (in MemberId id, in uint8 value)

DDS::ReturnCode_t	get_int16_value (inout short value, in MemberId id)

DDS::ReturnCode_t	set_int16_value (in MemberId id, in short value)

DDS::ReturnCode_t	get_uint16_value (inout unsigned short value, in MemberId id)

DDS::ReturnCode_t	set_uint16_value (in MemberId id, in unsigned short value)

DDS::ReturnCode_t	get_int64_value (inout long long value, in MemberId id)

DDS::ReturnCode_t	set_int64_value (in MemberId id, in long long value)

DDS::ReturnCode_t	get_uint64_value (inout unsigned long long value, in MemberId id)

DDS::ReturnCode_t	set_uint64_value (in MemberId id, in unsigned long long value)

DDS::ReturnCode_t	get_float32_value (inout float value, in MemberId id)

DDS::ReturnCode_t	set_float32_value (in MemberId id, in float value)

DDS::ReturnCode_t	get_float64_value (inout double value, in MemberId id)

DDS::ReturnCode_t	set_float64_value (in MemberId id, in double value)

DDS::ReturnCode_t	get_float128_value (inout long double value, in MemberId id)

DDS::ReturnCode_t	set_float128_value (in MemberId id, in long double value)

DDS::ReturnCode_t	get_char8_value (inout char value, in MemberId id)

DDS::ReturnCode_t	set_char8_value (in MemberId id, in char value)

DDS::ReturnCode_t	get_char16_value (inout wchar value, in MemberId id)

DDS::ReturnCode_t	set_char16_value (in MemberId id, in wchar value)

DDS::ReturnCode_t	get_byte_value (inout octet value, in MemberId id)

DDS::ReturnCode_t	set_byte_value (in MemberId id, in octet value)

DDS::ReturnCode_t	get_boolean_value (inout boolean value, in MemberId id)

DDS::ReturnCode_t	set_boolean_value (in MemberId id, in boolean value)

DDS::ReturnCode_t	get_string_value (inout string value, in MemberId id)

DDS::ReturnCode_t	set_string_value (in MemberId id, in string value)

DDS::ReturnCode_t	get_wstring_value (inout wstring value, in MemberId id)

DDS::ReturnCode_t	set_wstring_value (in MemberId id, in wstring value)

DDS::ReturnCode_t	get_complex_value (inout DynamicData value, in MemberId id)

DDS::ReturnCode_t	set_complex_value (in MemberId id, in DynamicData value)

DDS::ReturnCode_t	get_int32_values (inout Int32Seq value, in MemberId id)

DDS::ReturnCode_t	set_int32_values (in MemberId id, in Int32Seq value)

DDS::ReturnCode_t	get_uint32_values (inout UInt32Seq value, in MemberId id)

DDS::ReturnCode_t	set_uint32_values (in MemberId id, in UInt32Seq value)

DDS::ReturnCode_t	get_int8_values (inout Int8Seq value, in MemberId id)

DDS::ReturnCode_t	set_int8_values (in MemberId id, in Int8Seq value)

DDS::ReturnCode_t	get_uint8_values (inout UInt8Seq value, in MemberId id)

DDS::ReturnCode_t	set_uint8_values (in MemberId id, in UInt8Seq value)

DDS::ReturnCode_t	get_int16_values (inout Int16Seq value, in MemberId id)

DDS::ReturnCode_t	set_int16_values (in MemberId id, in Int16Seq value)

DDS::ReturnCode_t	get_uint16_values (inout UInt16Seq value, in MemberId id)

DDS::ReturnCode_t	set_uint16_values (in MemberId id, in UInt16Seq value)

DDS::ReturnCode_t	get_int64_values (inout Int64Seq value, in MemberId id)

DDS::ReturnCode_t	set_int64_values (in MemberId id, in Int64Seq value)

DDS::ReturnCode_t	get_uint64_values (inout UInt64Seq value, in MemberId id)

DDS::ReturnCode_t	set_uint64_values (in MemberId id, in UInt64Seq value)

DDS::ReturnCode_t	get_float32_values (inout Float32Seq value, in MemberId id)

DDS::ReturnCode_t	set_float32_values (in MemberId id, in Float32Seq value)

DDS::ReturnCode_t	get_float64_values (inout Float64Seq value, in MemberId id)

DDS::ReturnCode_t	set_float64_values (in MemberId id, in Float64Seq value)

DDS::ReturnCode_t	get_float128_values (inout Float128Seq value, in MemberId id)

DDS::ReturnCode_t	set_float128_values (in MemberId id, in Float128Seq value)

DDS::ReturnCode_t	get_char8_values (inout CharSeq value, in MemberId id)

DDS::ReturnCode_t	set_char8_values (in MemberId id, in CharSeq value)

DDS::ReturnCode_t	get_char16_values (inout WcharSeq value, in MemberId id)

DDS::ReturnCode_t	set_char16_values (in MemberId id, in WcharSeq value)

DDS::ReturnCode_t	get_byte_values (inout ByteSeq value, in MemberId id)

DDS::ReturnCode_t	set_byte_values (in MemberId id, in ByteSeq value)

DDS::ReturnCode_t	get_boolean_values (inout BooleanSeq value, in MemberId id)

DDS::ReturnCode_t	set_boolean_values (in MemberId id, in BooleanSeq value)

DDS::ReturnCode_t	get_string_values (inout StringSeq value, in MemberId id)

DDS::ReturnCode_t	set_string_values (in MemberId id, in StringSeq value)

DDS::ReturnCode_t	get_wstring_values (inout WstringSeq value, in MemberId id)

DDS::ReturnCode_t	set_wstring_values (in MemberId id, in WstringSeq value)

Public Member Functions inherited from OpenDDS::DCPS::LocalObjectBase
virtual void	_add_ref ()

virtual void	_remove_ref ()

virtual CORBA::ULong	_refcount_value () const

Public Member Functions inherited from CORBA::LocalObject
virtual	~LocalObject (void)

virtual CORBA::Boolean	_non_existent (void)

virtual char *	_repository_id (void)

virtual CORBA::InterfaceDef_ptr	_get_interface (void)

virtual CORBA::Object_ptr	_get_component (void)

virtual void	_create_request (CORBA::Context_ptr ctx, const char *operation, CORBA::NVList_ptr arg_list, CORBA::NamedValue_ptr result, CORBA::Request_ptr &request, CORBA::Flags req_flags)

virtual void	_create_request (CORBA::Context_ptr ctx, const char *operation, CORBA::NVList_ptr arg_list, CORBA::NamedValue_ptr result, CORBA::ExceptionList_ptr exclist, CORBA::ContextList_ptr ctxtlist, CORBA::Request_ptr &request, CORBA::Flags req_flags)

virtual CORBA::Request_ptr	_request (const char *operation)

CORBA::Policy_ptr	_get_policy (CORBA::PolicyType type)

CORBA::Policy_ptr	_get_cached_policy (TAO_Cached_Policy_Type type)

CORBA::Object_ptr	_set_policy_overrides (const CORBA::PolicyList &policies, CORBA::SetOverrideType set_add)

CORBA::PolicyList *	_get_policy_overrides (const CORBA::PolicyTypeSeq &types)

CORBA::Boolean	_validate_connection (CORBA::PolicyList_out inconsistent_policies)

virtual CORBA::ULong	_hash (CORBA::ULong maximum)

virtual CORBA::Boolean	_is_equivalent (CORBA::Object_ptr other_obj)

virtual CORBA::ORB_ptr	_get_orb (void)

virtual TAO::ObjectKey *	_key (void)

Public Member Functions inherited from CORBA::Object
virtual	~Object (void)

virtual TAO_Abstract_ServantBase *	_servant (void) const

virtual CORBA::Boolean	_is_collocated (void) const

virtual CORBA::Boolean	_is_local (void) const

	Object (TAO_Stub p, CORBA::Boolean collocated=false, TAO_Abstract_ServantBase servant=0, TAO_ORB_Core *orb_core=0)

	Object (IOP::IOR ior, TAO_ORB_Core orb_core)

virtual TAO_Stub *	_stubobj (void) const

virtual TAO_Stub *	_stubobj (void)

virtual void	_proxy_broker (TAO::Object_Proxy_Broker *proxy_broker)

virtual CORBA::Boolean	marshal (TAO_OutputCDR &cdr)

CORBA::Boolean	is_evaluated (void) const

TAO_ORB_Core *	orb_core (void) const

IOP::IOR *	steal_ior (void)

const IOP::IOR &	ior (void) const

virtual bool	can_convert_to_ior (void) const

virtual char *	convert_to_ior (bool use_omg_ior_format, const char *ior_prefix) const

void	_decr_refcount (void)

virtual CORBA::Boolean	_is_a (const char *logical_type_id)

virtual const char *	_interface_repository_id (void) const

CORBA::Policy_ptr	_get_policy (CORBA::PolicyType type)

CORBA::Policy_ptr	_get_cached_policy (TAO_Cached_Policy_Type type)

CORBA::Object_ptr	_set_policy_overrides (const CORBA::PolicyList &policies, CORBA::SetOverrideType set_add)

CORBA::PolicyList *	_get_policy_overrides (const CORBA::PolicyTypeSeq &types)

CORBA::Boolean	_validate_connection (CORBA::PolicyList_out inconsistent_policies)

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Private Types
enum	FoundStatus { FOUND_IN_COMPLEX_MAP, FOUND_IN_NON_COMPLEX_MAP, NOT_FOUND }

Private Member Functions
DDS::ReturnCode_t	get_simple_value_boolean (DCPS::Value &value, DDS::MemberId id) const

DDS::ReturnCode_t	get_simple_value_char (DCPS::Value &value, DDS::MemberId id) const

template<typename ValueType >
DDS::ReturnCode_t	get_simple_value_primitive (DCPS::Value &value, DDS::MemberId id) const

DDS::ReturnCode_t	get_simple_value_string (DCPS::Value &value, DDS::MemberId id) const

DDS::ReturnCode_t	get_simple_value_enum (DCPS::Value &value, DDS::MemberId id) const

CORBA::ULong	get_sequence_size () const

void	erase_member (DDS::MemberId id)

bool	read_basic_value (ACE_OutputCDR::from_int8 &value)
	Group of functions to read a basic value represented by this DynamicData instance. More...

bool	read_basic_value (ACE_OutputCDR::from_uint8 &value)

bool	read_basic_value (CORBA::Short &value)

bool	read_basic_value (CORBA::UShort &value)

bool	read_basic_value (CORBA::Long &value)

bool	read_basic_value (CORBA::ULong &value)

bool	read_basic_value (CORBA::LongLong &value)

bool	read_basic_value (CORBA::ULongLong &value)

bool	read_basic_value (CORBA::Float &value)

bool	read_basic_value (CORBA::Double &value)

bool	read_basic_value (CORBA::LongDouble &value)

bool	read_basic_value (ACE_OutputCDR::from_char &value)

bool	read_basic_value (ACE_OutputCDR::from_wchar &value)

bool	read_basic_value (ACE_OutputCDR::from_octet &value)

bool	read_basic_value (ACE_OutputCDR::from_boolean &value)

bool	read_basic_value (char *&value) const

void	cast_to_enum_value (ACE_OutputCDR::from_int8 &dst, CORBA::Long src) const

void	cast_to_enum_value (CORBA::Short &dst, CORBA::Long src) const

void	cast_to_enum_value (CORBA::Long &dst, CORBA::Long src) const

template<typename ValueType >
void	cast_to_enum_value (ValueType &dst, CORBA::Long src) const

template<typename ValueType >
bool	read_basic_in_single_map (ValueType &value, DDS::MemberId id)
	Read a basic member from a containing type. More...

template<typename ValueType >
bool	read_basic_in_complex_map (ValueType &value, DDS::MemberId id)

template<typename ValueType >
bool	read_basic_member (ValueType &value, DDS::MemberId id)

template<typename ValueType >
bool	get_value_from_self (ValueType &value, DDS::MemberId id)

template<TypeKind ValueTypeKind, typename ValueType >
bool	get_value_from_enum (ValueType &value, DDS::MemberId id)

template<TypeKind ValueTypeKind, typename ValueType >
bool	get_value_from_bitmask (ValueType &value, DDS::MemberId id)

template<TypeKind ValueTypeKind, typename ValueType >
bool	get_value_from_struct (ValueType &value, DDS::MemberId id)

template<TypeKind ValueTypeKind, typename ValueType >
bool	get_value_from_union (ValueType &value, DDS::MemberId id)

template<TypeKind ValueTypeKind, typename ValueType >
bool	get_value_from_collection (ValueType &value, DDS::MemberId id)

template<TypeKind CharKind, TypeKind StringKind, typename FromCharT , typename CharT >
DDS::ReturnCode_t	get_char_common (CharT &value, DDS::MemberId id)

template<typename UIntType >
bool	get_boolean_from_bitmask (CORBA::ULong index, CORBA::Boolean &value)

template<TypeKind MemberTypeKind, typename MemberType >
bool	set_value_to_struct (DDS::MemberId id, const MemberType &value)

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const ACE_OutputCDR::from_boolean &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const ACE_OutputCDR::from_octet &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const ACE_OutputCDR::from_char &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const ACE_OutputCDR::from_int8 &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const ACE_OutputCDR::from_uint8 &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::Short &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::UShort &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::Long &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::ULong &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::LongLong &value) const

bool	cast_to_discriminator_value (CORBA::Long &disc_value, const CORBA::ULongLong &value) const

template<typename MemberType >
bool	cast_to_discriminator_value (CORBA::Long &disc_value, const MemberType &value) const

template<TypeKind MemberTypeKind, typename MemberType >
bool	set_value_to_union (DDS::MemberId id, const MemberType &value, TypeKind enum_or_bitmask=TK_NONE, LBound lower=0, LBound upper=0)

template<TypeKind ElementTypeKind, typename ElementType >
bool	set_value_to_collection (DDS::MemberId id, const ElementType &value, TypeKind coll_tk, TypeKind enum_or_bitmask=TK_NONE, LBound lower=0, LBound upper=0)

template<TypeKind ValueTypeKind, typename ValueType >
DDS::ReturnCode_t	set_single_value (DDS::MemberId id, const ValueType &value, TypeKind enum_or_bitmask=TK_NONE, LBound lower=0, LBound upper=0)

template<TypeKind CharKind, TypeKind StringKind, typename FromCharT >
DDS::ReturnCode_t	set_char_common (DDS::MemberId id, const FromCharT &value)

bool	check_index_from_id (TypeKind tk, DDS::MemberId id, CORBA::ULong bound) const

bool	is_default_member_selected (CORBA::Long disc_val, DDS::MemberId default_id) const

bool	read_discriminator (CORBA::Long &disc_val) const

DDS::MemberId	find_selected_member () const

bool	validate_discriminator (CORBA::Long disc_val, const DDS::MemberDescriptor_var &md) const

bool	set_complex_to_struct (DDS::MemberId id, DDS::DynamicData_var value)

bool	set_complex_to_union (DDS::MemberId id, DDS::DynamicData_var value, const DDS::TypeDescriptor_var &descriptor)

bool	set_complex_to_collection (DDS::MemberId id, DDS::DynamicData_var value, TypeKind tk)

bool	validate_member_id_collection (const DDS::TypeDescriptor_var &descriptor, DDS::MemberId id, TypeKind collection_tk) const

DDS::ReturnCode_t	clear_value_i (DDS::MemberId id, const DDS::DynamicType_var &member_type)

bool	insert_single (DDS::MemberId id, const ACE_OutputCDR::from_int8 &value)

bool	insert_single (DDS::MemberId id, const ACE_OutputCDR::from_uint8 &value)

bool	insert_single (DDS::MemberId id, const ACE_OutputCDR::from_char &value)

bool	insert_single (DDS::MemberId id, const ACE_OutputCDR::from_octet &value)

bool	insert_single (DDS::MemberId id, const ACE_OutputCDR::from_boolean &value)

template<typename SingleType >
bool	insert_single (DDS::MemberId id, const SingleType &value)

bool	insert_complex (DDS::MemberId id, const DDS::DynamicData_var &value)

template<typename SequenceType >
bool	insert_sequence (DDS::MemberId id, const SequenceType &value)

template<TypeKind ElementTypeKind>
bool	check_seqmem_in_struct_and_union (DDS::MemberId id, TypeKind enum_or_bitmask, LBound lower, LBound upper) const

template<TypeKind ElementTypeKind>
bool	check_seqmem_in_sequence_and_array (DDS::MemberId id, CORBA::ULong bound, TypeKind enum_or_bitmask, LBound lower, LBound upper) const

template<TypeKind ElementTypeKind, typename SequenceType >
bool	set_values_to_struct (DDS::MemberId id, const SequenceType &value, TypeKind enum_or_bitmask, LBound lower, LBound upper)

template<TypeKind ElementTypeKind, typename SequenceType >
bool	set_values_to_union (DDS::MemberId id, const SequenceType &value, TypeKind enum_or_bitmask, LBound lower, LBound upper)

template<TypeKind ElementTypeKind, typename SequenceType >
bool	set_values_to_sequence (DDS::MemberId id, const SequenceType &value, TypeKind enum_or_bitmask, LBound lower, LBound upper)

template<TypeKind ElementTypeKind, typename SequenceType >
bool	set_values_to_array (DDS::MemberId id, const SequenceType &value, TypeKind enum_or_bitmask, LBound lower, LBound upper)

template<TypeKind ElementTypeKind, typename SequenceType >
DDS::ReturnCode_t	set_sequence_values (DDS::MemberId id, const SequenceType &value, TypeKind enum_or_bitmask=TK_NONE, LBound lower=0, LBound upper=0)

template<TypeKind ValueTypeKind, typename ValueType >
DDS::ReturnCode_t	get_single_value (ValueType &value, DDS::MemberId id)

typedef	OPENDDS_VECTOR (CORBA::ULong) IndexToIdMap

bool	move_single_to_complex (const DataContainer::const_single_iterator &it, DynamicDataImpl *data)

bool	move_single_to_complex_i (const DataContainer::const_single_iterator &it, DynamicDataImpl *data, const TypeKind treat_as)

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

bool	move_sequence_to_complex (const DataContainer::const_sequence_iterator &it, DynamicDataImpl *data)

bool	get_complex_from_aggregated (DDS::DynamicData_var &value, DDS::MemberId id, FoundStatus &found_status)

bool	get_complex_from_struct (DDS::DynamicData_ptr &value, DDS::MemberId id)

bool	write_discriminator_helper (CORBA::Long value, TypeKind treat_as)

bool	write_discriminator (CORBA::Long value)

bool	get_complex_from_union (DDS::DynamicData_ptr &value, DDS::MemberId id)

bool	get_complex_from_collection (DDS::DynamicData_ptr &value, DDS::MemberId id)

bool	read_discriminator (CORBA::Long &disc_val, const DDS::DynamicType_var &disc_type, DataContainer::const_single_iterator it) const

bool	insert_valid_discriminator (DDS::MemberDescriptor *memberSelected)

bool	insert_discriminator (ACE_CDR::Long value)

void	clear_container ()

bool	serialized_size_i (const DCPS::Encoding &encoding, size_t &size, DCPS::Sample::Extent ext) const

bool	serialize_i (DCPS::Serializer &ser, DCPS::Sample::Extent ext) const

template<>
bool	get_value_from_enum (char *&, DDS::MemberId)

template<>
bool	get_value_from_enum (CORBA::WChar *&, DDS::MemberId)

template<>
bool	get_value_from_bitmask (char *&, DDS::MemberId)

template<>
bool	get_value_from_bitmask (CORBA::WChar *&, DDS::MemberId)

Static Private Member Functions
static bool	is_valid_discriminator_type (TypeKind tk)

Private Attributes
DataContainer	container_

Friends
OpenDDS_Dcps_Export bool	DCPS::serialized_size (const DCPS::Encoding &encoding, size_t &size, const DynamicDataImpl &data)

OpenDDS_Dcps_Export bool	DCPS::operator<< (DCPS::Serializer &ser, const DynamicDataImpl &data)

OpenDDS_Dcps_Export bool	DCPS::serialized_size (const DCPS::Encoding &encoding, size_t &size, const DCPS::KeyOnly< const DynamicDataImpl > &data)

OpenDDS_Dcps_Export bool	DCPS::operator<< (DCPS::Serializer &ser, const DCPS::KeyOnly< const DynamicDataImpl > &data)

Additional Inherited Members
Public Types inherited from OpenDDS::DCPS::LocalObject< DDS::DynamicData >
typedef DDS::DynamicData ::_ptr_type	_ptr_type

typedef DDS::DynamicData ::_var_type	_var_type

Public Types inherited from CORBA::LocalObject
typedef LocalObject_ptr	_ptr_type

typedef LocalObject_var	_var_type

typedef LocalObject_out	_out_type

Public Types inherited from CORBA::Object
typedef Object_ptr	_ptr_type

typedef Object_var	_var_type

typedef Object_out	_out_type

Static Public Member Functions inherited from OpenDDS::XTypes::DynamicDataBase
static bool	has_explicit_keys (DDS::DynamicType *dt)

static bool	exclude_member (DCPS::Sample::Extent ext, bool is_key, bool has_explicit_keys)

static DCPS::Sample::Extent	nested (DCPS::Sample::Extent ext)

Static Public Member Functions inherited from OpenDDS::DCPS::LocalObject< DDS::DynamicData >
static _ptr_type	_narrow (CORBA::Object_ptr obj)

Static Public Member Functions inherited from CORBA::LocalObject
static LocalObject_ptr	_duplicate (LocalObject_ptr obj)

static LocalObject_ptr	_nil (void)

static LocalObject_ptr	_narrow (CORBA::Object_ptr obj)

Static Public Member Functions inherited from CORBA::Object
static CORBA::Boolean	marshal (const Object_ptr x, TAO_OutputCDR &cdr)

static void	_tao_any_destructor (void *)

static CORBA::Boolean	is_nil_i (CORBA::Object_ptr obj)

static void	tao_object_initialize (Object *)

static CORBA::Object_ptr	_duplicate (CORBA::Object_ptr obj)

static CORBA::Object_ptr	_nil (void)

static CORBA::Object_ptr	_narrow (CORBA::Object_ptr obj)

Public Attributes inherited from DDS::DynamicData
readonly attribute DynamicType	type

Protected Member Functions inherited from OpenDDS::XTypes::DynamicDataBase
bool	is_type_supported (TypeKind tk, const char *func_name)

bool	is_primitive (TypeKind tk) const

bool	is_basic (TypeKind tk) const

bool	is_complex (TypeKind tk) const

bool	get_index_from_id (DDS::MemberId id, ACE_CDR::ULong &index, ACE_CDR::ULong bound) const

bool	enum_string_helper (char *&strInOut, MemberId id)

DDS::ReturnCode_t	check_member (DDS::MemberDescriptor_var &md, DDS::DynamicType_var &type, const char method, const char what, DDS::MemberId id, DDS::TypeKind tk)

DDS::DynamicData *	interface_from_this () const

Protected Member Functions inherited from CORBA::LocalObject
	LocalObject (void)

Protected Member Functions inherited from CORBA::Object
	Object (int dummy=0)

TAO::Object_Proxy_Broker *	proxy_broker () const

Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Static Protected Member Functions inherited from OpenDDS::XTypes::DynamicDataBase
static CORBA::ULong	bound_total (DDS::TypeDescriptor_var descriptor)

static DDS::MemberId	get_union_default_member (DDS::DynamicType *type)

static bool	discriminator_selects_no_member (DDS::DynamicType *type, ACE_CDR::Long disc)

Protected Attributes inherited from OpenDDS::XTypes::DynamicDataBase
DDS::DynamicType_var	type_
	The actual (i.e., non-alias) DynamicType of the associated type. More...

Protected Attributes inherited from CORBA::Object
ACE_Atomic_Op< TAO_SYNCH_MUTEX, unsigned long >	refcount_

Detailed Description

Definition at line 36 of file DynamicDataImpl.h.

Member Enumeration Documentation

◆ FoundStatus

enum OpenDDS::XTypes::DynamicDataImpl::FoundStatus

private

Enumerator
FOUND_IN_COMPLEX_MAP
FOUND_IN_NON_COMPLEX_MAP
NOT_FOUND

Definition at line 996 of file DynamicDataImpl.h.

996 { FOUND_IN_COMPLEX_MAP, FOUND_IN_NON_COMPLEX_MAP, NOT_FOUND };

OpenDDS::XTypes::DynamicDataImpl::FOUND_IN_NON_COMPLEX_MAP

Definition: DynamicDataImpl.h:996

OpenDDS::XTypes::DynamicDataImpl::FOUND_IN_COMPLEX_MAP

Definition: DynamicDataImpl.h:996

OpenDDS::XTypes::DynamicDataImpl::NOT_FOUND

Definition: DynamicDataImpl.h:996

Constructor & Destructor Documentation

◆ DynamicDataImpl() [1/2]

OpenDDS::XTypes::DynamicDataImpl::DynamicDataImpl ( DDS::DynamicType_ptr type )

explicit

Definition at line 26 of file DynamicDataImpl.cpp.

Referenced by clear_value_i(), clone(), get_complex_from_aggregated(), get_complex_from_collection(), get_complex_from_union(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_sequence_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_complex_aggregated_member_xcdr2_default(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_complex_member().

   : DynamicDataBase(type)
   , container_(type_, this)
 {
 }

◆ DynamicDataImpl() [2/2]

OpenDDS::XTypes::DynamicDataImpl::DynamicDataImpl ( const DynamicDataImpl & other )

Definition at line 32 of file DynamicDataImpl.cpp.

   : CORBA::Object()
   , DynamicData()
   , CORBA::LocalObject()
   , DCPS::RcObject()
   , DynamicDataBase(other.type_)
   , container_(other.container_, this)
 {}

Member Function Documentation

◆ cast_to_discriminator_value() [1/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const ACE_OutputCDR::from_boolean &	value
	)		const

private

Definition at line 1363 of file DynamicDataImpl.cpp.

References ACE_OutputCDR::from_boolean::val_.

Referenced by cast_to_discriminator_value(), get_value_from_union(), and set_value_to_union().

 {
   disc_value = static_cast<CORBA::Long>(value.val_);
   return true;
 }

◆ cast_to_discriminator_value() [2/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const ACE_OutputCDR::from_octet &	value
	)		const

private

Definition at line 1370 of file DynamicDataImpl.cpp.

References ACE_OutputCDR::from_octet::val_.

 {
   disc_value = static_cast<CORBA::Long>(value.val_);
   return true;
 }

◆ cast_to_discriminator_value() [3/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const ACE_OutputCDR::from_char &	value
	)		const

private

Definition at line 1377 of file DynamicDataImpl.cpp.

References cast_to_discriminator_value(), ACE_OutputCDR::from_wchar::val_, and ACE_OutputCDR::from_char::val_.

 {
   disc_value = static_cast<CORBA::Long>(value.val_);
   return true;
 }

◆ cast_to_discriminator_value() [4/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const ACE_OutputCDR::from_int8 &	value
	)		const

private

Definition at line 1393 of file DynamicDataImpl.cpp.

References ACE_OutputCDR::from_int8::val_.

 {
   disc_value = static_cast<CORBA::Long>(value.val_);
   return true;
 }

◆ cast_to_discriminator_value() [5/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const ACE_OutputCDR::from_uint8 &	value
	)		const

private

Definition at line 1400 of file DynamicDataImpl.cpp.

References ACE_OutputCDR::from_uint8::val_.

 {
   disc_value = static_cast<CORBA::Long>(value.val_);
   return true;
 }

◆ cast_to_discriminator_value() [6/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::Short &	value
	)		const

private

Definition at line 1407 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = static_cast<CORBA::Long>(value);
   return true;
 }

◆ cast_to_discriminator_value() [7/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::UShort &	value
	)		const

private

Definition at line 1414 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = static_cast<CORBA::Long>(value);
   return true;
 }

◆ cast_to_discriminator_value() [8/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::Long &	value
	)		const

private

Definition at line 1421 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = value;
   return true;
 }

◆ cast_to_discriminator_value() [9/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::ULong &	value
	)		const

private

Definition at line 1428 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = static_cast<CORBA::Long>(value);
   return true;
 }

◆ cast_to_discriminator_value() [10/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::LongLong &	value
	)		const

private

Definition at line 1435 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = static_cast<CORBA::Long>(value);
   return true;
 }

◆ cast_to_discriminator_value() [11/12]

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const CORBA::ULongLong &	value
	)		const

private

Definition at line 1442 of file DynamicDataImpl.cpp.

References value.

 {
   disc_value = static_cast<CORBA::Long>(value);
   return true;
 }

◆ cast_to_discriminator_value() [12/12]

template<typename MemberType >

bool OpenDDS::XTypes::DynamicDataImpl::cast_to_discriminator_value	(	CORBA::Long &	disc_value,
		const MemberType &	value
	)		const

private

Definition at line 1450 of file DynamicDataImpl.cpp.

 {
   return false;
 }

◆ cast_to_enum_value() [1/4]

void OpenDDS::XTypes::DynamicDataImpl::cast_to_enum_value	(	ACE_OutputCDR::from_int8 &	dst,
		CORBA::Long	src
	)		const

private

Definition at line 2952 of file DynamicDataImpl.cpp.

Referenced by get_value_from_enum().

 {
   dst = ACE_OutputCDR::from_int8(static_cast<CORBA::Int8>(src));
 }

◆ cast_to_enum_value() [2/4]

void OpenDDS::XTypes::DynamicDataImpl::cast_to_enum_value	(	CORBA::Short &	dst,
		CORBA::Long	src
	)		const

private

Definition at line 2957 of file DynamicDataImpl.cpp.

 {
   dst = static_cast<CORBA::Short>(src);
 }

◆ cast_to_enum_value() [3/4]

void OpenDDS::XTypes::DynamicDataImpl::cast_to_enum_value	(	CORBA::Long &	dst,
		CORBA::Long	src
	)		const

private

Definition at line 2962 of file DynamicDataImpl.cpp.

 {
   dst = src;
 }

◆ cast_to_enum_value() [4/4]

template<typename ValueType >

void OpenDDS::XTypes::DynamicDataImpl::cast_to_enum_value	(	ValueType &	dst,
		CORBA::Long	src
	)		const

private

Definition at line 2968 of file DynamicDataImpl.cpp.

2969 {}

◆ check_index_from_id()

bool OpenDDS::XTypes::DynamicDataImpl::check_index_from_id	(	TypeKind	tk,
		DDS::MemberId	id,
		CORBA::ULong	bound
	)		const

private

Definition at line 1632 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_BITMASK, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRING16, and OpenDDS::XTypes::TK_STRING8.

Referenced by check_seqmem_in_sequence_and_array(), set_boolean_value(), set_char_common(), and validate_member_id_collection().

 {
   // The given Id is treated as index.
   switch (tk) {
   case TK_STRING8:
   case TK_STRING16:
   case TK_SEQUENCE:
   case TK_MAP:
     // Bound of 0 means unbounded.
     if (bound == 0 || id < bound) {
       return true;
     }
     break;
   case TK_BITMASK:
   case TK_ARRAY:
     if (id < bound) {
       return true;
     }
     break;
   }
   return false;
 }

◆ check_seqmem_in_sequence_and_array()

template<TypeKind ElementTypeKind>

bool OpenDDS::XTypes::DynamicDataImpl::check_seqmem_in_sequence_and_array	(	DDS::MemberId	id,
		CORBA::ULong	bound,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)		const

private

Definition at line 2365 of file DynamicDataImpl.cpp.

References check_index_from_id(), OpenDDS::XTypes::get_base_type(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_SEQUENCE, and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   if (!check_index_from_id(type_->get_kind(), id, bound)) {
     return false;
   }
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var elem_type = get_base_type(descriptor->element_type());
   const TypeKind elem_tk = elem_type->get_kind();
   if (elem_tk != TK_SEQUENCE) {
     return false;
   }
 
   DDS::TypeDescriptor_var elem_td;
   if (elem_type->get_descriptor(elem_td) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var nested_elem_type = get_base_type(elem_td->element_type());
   const TypeKind nested_elem_tk = nested_elem_type->get_kind();
   if (nested_elem_tk != ElementTypeKind && nested_elem_tk != enum_or_bitmask) {
     return false;
   }
   if (nested_elem_tk == enum_or_bitmask) {
     DDS::TypeDescriptor_var nested_elem_td;
     if (nested_elem_type->get_descriptor(nested_elem_td) != DDS::RETCODE_OK) {
       return false;
     }
     const CORBA::ULong bit_bound = nested_elem_td->bound()[0];
     if (bit_bound < lower || bit_bound > upper) {
       return false;
     }
   }
   return true;
 }

◆ check_seqmem_in_struct_and_union()

template<TypeKind ElementTypeKind>

bool OpenDDS::XTypes::DynamicDataImpl::check_seqmem_in_struct_and_union	(	DDS::MemberId	id,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)		const

private

Definition at line 2282 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::get_base_type(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_SEQUENCE, and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, id)) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (member->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var member_type = get_base_type(md->type());
   const TypeKind member_tk = member_type->get_kind();
   if (member_tk != TK_SEQUENCE) {
     return false;
   }
 
   DDS::TypeDescriptor_var member_td;
   if (member_type->get_descriptor(member_td) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var elem_type = get_base_type(member_td->element_type());
   const TypeKind elem_tk = elem_type->get_kind();
   if (elem_tk != ElementTypeKind && elem_tk != enum_or_bitmask) {
     return false;
   }
 
   if (elem_tk == enum_or_bitmask) {
     DDS::TypeDescriptor_var elem_td;
     if (elem_type->get_descriptor(elem_td) != DDS::RETCODE_OK) {
       return false;
     }
     const CORBA::ULong bit_bound = elem_td->bound()[0];
     if (bit_bound < lower || bit_bound > upper) {
       return false;
     }
   }
   return true;
 }

◆ clear_all_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::clear_all_values ( )

Implements DDS::DynamicData.

Definition at line 328 of file DynamicDataImpl.cpp.

 {
   const TypeKind tk = type_->get_kind();
   if (is_primitive(tk) || tk == TK_ENUM) {
     return clear_value_i(MEMBER_ID_INVALID, type_);
   }
 
   switch (tk) {
   case TK_BITMASK:
   case TK_ARRAY:
   case TK_STRING8:
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
 #endif
   case TK_SEQUENCE:
   case TK_STRUCTURE:
   case TK_UNION:
     clear_container();
     break;
   case TK_MAP:
   case TK_BITSET:
   case TK_ALIAS:
   case TK_ANNOTATION:
   default:
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::clear_all_values:"
                  " Encounter unexpected type kind %C\n", typekind_to_string(tk)));
     }
     return DDS::RETCODE_ERROR;
   }
   return DDS::RETCODE_OK;
 }

◆ clear_container()

void OpenDDS::XTypes::DynamicDataImpl::clear_container ( )

private

Definition at line 361 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataImpl::DataContainer::clear(), and container_.

Referenced by clear_all_values(), set_complex_to_union(), set_value_to_union(), and set_values_to_union().

 {
   container_.single_map_.clear();
   container_.sequence_map_.clear();
   container_.complex_map_.clear();
 }

◆ clear_nonkey_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::clear_nonkey_values ( )

Implements DDS::DynamicData.

Definition at line 368 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ clear_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::clear_value ( DDS::MemberId id )

Definition at line 373 of file DynamicDataImpl.cpp.

 {
   const TypeKind this_tk = type_->get_kind();
   if (is_primitive(this_tk) || this_tk == TK_ENUM) {
     if (id != MEMBER_ID_INVALID) {
       return DDS::RETCODE_BAD_PARAMETER;
     }
     return clear_value_i(id, type_);
   }
 
   switch (this_tk) {
   case TK_BITMASK:
     return set_boolean_value(id, false);
   case TK_ARRAY: {
     DDS::TypeDescriptor_var td;
     if (type_->get_descriptor(td) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     const CORBA::ULong bound = bound_total(td);
     if (id >= bound) {
       return DDS::RETCODE_BAD_PARAMETER;
     }
     DDS::DynamicType_var elem_type = get_base_type(td->element_type());
     return clear_value_i(id, elem_type);
   }
   case TK_STRING8:
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
 #endif
   case TK_SEQUENCE: {
     // Shift subsequent elements to the left (XTypes spec 7.5.2.11.3).
     const CORBA::ULong size = get_sequence_size();
     if (id >= size) {
       return DDS::RETCODE_ERROR;
     }
 
     // At the begin of each iterator, member with the current id is not present
     // in any of the maps. Copy over the next member to the current id.
     erase_member(id);
     for (CORBA::ULong i = id; i < size - 1; ++i) {
       const DDS::MemberId next_id = i + 1;
       DataContainer::const_single_iterator single_it = container_.single_map_.find(next_id);
       if (single_it != container_.single_map_.end()) {
         container_.single_map_.insert(std::make_pair(i, single_it->second));
         container_.single_map_.erase(next_id);
         continue;
       }
       DataContainer::const_sequence_iterator seq_it = container_.sequence_map_.find(next_id);
       if (seq_it != container_.sequence_map_.end()) {
         container_.sequence_map_.insert(std::make_pair(i, seq_it->second));
         container_.sequence_map_.erase(next_id);
         continue;
       }
       DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(next_id);
       if (complex_it != container_.complex_map_.end()) {
         container_.complex_map_.insert(std::make_pair(i, complex_it->second));
         container_.complex_map_.erase(next_id);
         continue;
       }
     }
     break;
   }
   case TK_STRUCTURE:
   case TK_UNION: {
     DDS::DynamicTypeMember_var dtm;
     if (type_->get_member(dtm, id) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     DDS::MemberDescriptor_var md;
     if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     if (md->is_optional()) {
       erase_member(id);
       break;
     }
     DDS::DynamicType_var member_type = get_base_type(md->type());
     return clear_value_i(id, member_type);
   }
   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: DynamicDataImpl::clear_value:"
                  " Encounter unexpected type kind %C\n", typekind_to_string(this_tk)));
     }
     return DDS::RETCODE_ERROR;
   }
   return DDS::RETCODE_OK;
 }

◆ clear_value_i()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::clear_value_i	(	DDS::MemberId	id,
		const DDS::DynamicType_var &	member_type
	)

private

Definition at line 466 of file DynamicDataImpl.cpp.

Referenced by clear_all_values(), clear_value(), get_complex_from_union(), and get_value_from_union().

 {
   const TypeKind tk = member_type->get_kind();
   switch (tk) {
   case TK_BOOLEAN: {
     ACE_OutputCDR::from_boolean val(false);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_BYTE: {
     ACE_OutputCDR::from_octet val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_UINT8: {
     ACE_OutputCDR::from_uint8 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_UINT16: {
     CORBA::UInt16 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_UINT32: {
     CORBA::UInt32 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_UINT64: {
     CORBA::UInt64 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_INT8: {
     ACE_OutputCDR::from_int8 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_INT16: {
     CORBA::Int16 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_INT32: {
     CORBA::Int32 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_INT64: {
     CORBA::Int64 val(0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_FLOAT32: {
     CORBA::Float val(0.0f);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_FLOAT64: {
     CORBA::Double val(0.0);
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_FLOAT128: {
     CORBA::LongDouble val;
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_CHAR8: {
     ACE_OutputCDR::from_char val('\0');
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_STRING8: {
     const char* val = 0;
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16: {
     ACE_OutputCDR::from_wchar val(L'\0');
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
   case TK_STRING16: {
     const CORBA::WChar* val = 0;
     container_.set_default_basic_value(val);
     insert_single(id, val);
     break;
   }
 #endif
   case TK_ENUM: {
     // Set to first enumerator
     CORBA::Long value;
     if (!container_.set_default_enum_value(member_type, value)) {
       return DDS::RETCODE_ERROR;
     }
     TypeKind treat_as = tk;
     if (enum_bound(member_type, treat_as) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     if (treat_as == TK_INT8) {
       ACE_OutputCDR::from_int8 val(static_cast<CORBA::Int8>(value));
       insert_single(id, val);
     } else if (treat_as == TK_INT16) {
       insert_single(id, static_cast<CORBA::Short>(value));
     } else {
       insert_single(id, value);
     }
     break;
   }
   case TK_BITMASK: {
     // Set to default bitmask value
     TypeKind treat_as = tk;
     if (bitmask_bound(member_type, treat_as) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     if (treat_as == TK_UINT8) {
       ACE_OutputCDR::from_uint8 val(0);
       container_.set_default_bitmask_value(val);
       insert_single(id, val);
     } else if (treat_as == TK_UINT16) {
       CORBA::UShort val;
       container_.set_default_bitmask_value(val);
       insert_single(id, val);
     } else if (treat_as == TK_UINT32) {
       CORBA::ULong val;
       container_.set_default_bitmask_value(val);
       insert_single(id, val);
     } else {
       CORBA::ULongLong val;
       container_.set_default_bitmask_value(val);
       insert_single(id, val);
     }
     break;
   }
   case TK_ARRAY:
   case TK_SEQUENCE:
   case TK_STRUCTURE:
   case TK_UNION: {
     DDS::DynamicData_var dd = new DynamicDataImpl(member_type);
     insert_complex(id, dd);
     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: DynamicDataImpl::clear_value_i:"
                  " Member %u has unexpected type kind %C\n", id, typekind_to_string(tk)));
     }
     return DDS::RETCODE_ERROR;
   }
   return DDS::RETCODE_OK;
 }

◆ clone()

DDS::DynamicData_ptr OpenDDS::XTypes::DynamicDataImpl::clone ( void )

Implements DDS::DynamicData.

Definition at line 653 of file DynamicDataImpl.cpp.

References DynamicDataImpl().

 {
   return new DynamicDataImpl(*this);
 }

◆ equals()

CORBA::Boolean OpenDDS::XTypes::DynamicDataImpl::equals ( DDS::DynamicData_ptr other )

Definition at line 51 of file DynamicDataImpl.cpp.

References ACE_ERROR, and LM_ERROR.

Referenced by set_complex_to_union().

 {
   // FUTURE: Implement this.
   ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: DynamicDataImpl::equals: Not implemented\n"));
   return false;
 }

◆ erase_member()

void OpenDDS::XTypes::DynamicDataImpl::erase_member ( DDS::MemberId id )

private

Definition at line 208 of file DynamicDataImpl.cpp.

References container_.

Referenced by clear_value().

 {
   if (container_.single_map_.erase(id) == 0) {
     if (container_.sequence_map_.erase(id) == 0) {
       container_.complex_map_.erase(id);
     }
   }
 }

◆ find_selected_member()

DDS::MemberId OpenDDS::XTypes::DynamicDataImpl::find_selected_member ( ) const

private

Definition at line 1310 of file DynamicDataImpl.cpp.

References container_, OpenDDS::XTypes::DISCRIMINATOR_ID, OpenDDS::XTypes::MEMBER_ID_INVALID, and OPENDDS_ASSERT.

Referenced by set_complex_to_union(), and set_value_to_union().

 {
   // There can be at most 2 entries in total in all three maps,
   // one for the discriminator, one for a selected member.
   for (DataContainer::const_single_iterator single_it = container_.single_map_.begin();
        single_it != container_.single_map_.end(); ++single_it) {
     if (single_it->first != DISCRIMINATOR_ID) {
       return single_it->first;
     }
   }
 
   // If there is any entry in sequence_map_, that must be for a selected member
   // since discriminator cannot be sequence.
   if (container_.sequence_map_.size() > 0) {
     OPENDDS_ASSERT(container_.sequence_map_.size() == 1);
     return container_.sequence_map_.begin()->first;
   }
 
   for (DataContainer::const_complex_iterator cmpl_it = container_.complex_map_.begin();
        cmpl_it != container_.complex_map_.end(); ++cmpl_it) {
     if (cmpl_it->first != DISCRIMINATOR_ID) {
       return cmpl_it->first;
     }
   }
 
   // There was no selected member written.
   return MEMBER_ID_INVALID;
 }

◆ get_boolean_from_bitmask()

template<typename UIntType >

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

private

Definition at line 3227 of file DynamicDataImpl.cpp.

References read_basic_value().

 {
   UIntType bitmask;
   if (!read_basic_value(bitmask)) {
     return false;
   }
   value = (1ULL << index) & bitmask;
   return true;
 }

◆ get_boolean_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_boolean_value	(	CORBA::Boolean &	value,
		DDS::MemberId	id
	)

Definition at line 3248 of file DynamicDataImpl.cpp.

References ACE_ERROR, container_, OpenDDS::XTypes::DynamicDataBase::get_index_from_id(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value(), OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_BITMASK, OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), ACE_OutputCDR::from_boolean::val_, and value.

Referenced by read_basic_value().

 {
   const TypeKind tk = type_->get_kind();
   bool good = true;
   switch (tk) {
   case TK_BOOLEAN: {
     if (id != MEMBER_ID_INVALID) {
       good = false;
       break;
     }
     DataContainer::const_single_iterator it = container_.single_map_.find(id);
     if (it != container_.single_map_.end()) {
       ACE_OutputCDR::from_boolean from_bool = it->second.get<ACE_OutputCDR::from_boolean>();
       value = from_bool.val_;
     } else {
       ACE_OutputCDR::from_boolean from_bool(false);
       container_.set_default_basic_value(from_bool);
       value = from_bool.val_;
     }
     break;
   }
   case TK_BITMASK: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       good = false;
       break;
     }
     const LBound bitbound = descriptor->bound()[0];
     ACE_CDR::ULong index;
     if (!get_index_from_id(id, index, bitbound)) {
       good = false;
       break;
     }
     if (bitbound >= 1 && bitbound <= 8) {
       good = get_boolean_from_bitmask<CORBA::UInt8>(index, value);
     } else if (bitbound >= 9 && bitbound <= 16) {
       good = get_boolean_from_bitmask<CORBA::UShort>(index, value);
     } else if (bitbound >= 17 && bitbound <= 32) {
       good = get_boolean_from_bitmask<CORBA::ULong>(index, value);
     } else {
       good = get_boolean_from_bitmask<CORBA::ULongLong>(index, value);
     }
     break;
   }
   case TK_STRUCTURE: {
     ACE_OutputCDR::from_boolean from_bool(false);
     good = get_value_from_struct<TK_BOOLEAN>(from_bool, id);
     if (good) {
       value = from_bool.val_;
     }
     break;
   }
   case TK_UNION: {
     ACE_OutputCDR::from_boolean from_bool(false);
     good = get_value_from_union<TK_BOOLEAN>(from_bool, id);
     if (good) {
       value = from_bool.val_;
     }
     break;
   }
   case TK_SEQUENCE:
   case TK_ARRAY: {
     ACE_OutputCDR::from_boolean from_bool(false);
     good = get_value_from_collection<TK_BOOLEAN>(from_bool, id);
     if (good) {
       value = from_bool.val_;
     }
     break;
   }
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_boolean_value:"
                  " Map is currently not supported\n"));
     }
     good = false;
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_boolean_value:"
                " Failed to read a boolean value from a DynamicData object of type %C\n",
                typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ get_boolean_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_boolean_values	(	DDS::BooleanSeq &	value,
		DDS::MemberId	id
	)

Definition at line 4012 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_byte_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_byte_value	(	CORBA::Octet &	value,
		DDS::MemberId	id
	)

Definition at line 3216 of file DynamicDataImpl.cpp.

References DDS::RETCODE_OK.

Referenced by read_basic_value().

 {
   ACE_OutputCDR::from_octet from_octet(0);
   const DDS::ReturnCode_t rc = get_single_value<TK_BYTE>(from_octet, id);
   if (rc == DDS::RETCODE_OK) {
     value = from_octet.val_;
   }
   return rc;
 }

◆ get_byte_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_byte_values	(	DDS::ByteSeq &	value,
		DDS::MemberId	id
	)

Definition at line 4005 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_char16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_char16_value	(	CORBA::WChar &	value,
		DDS::MemberId	id
	)

Definition at line 3207 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED, and value.

Referenced by read_basic_value().

 {
 #ifdef DDS_HAS_WCHAR
   return get_char_common<TK_CHAR16, TK_STRING16, ACE_OutputCDR::from_wchar>(value, id);
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ get_char16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_char16_values	(	DDS::WcharSeq &	value,
		DDS::MemberId	id
	)

Definition at line 3998 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_char8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_char8_value	(	CORBA::Char &	value,
		DDS::MemberId	id
	)

Definition at line 3202 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_char_common<TK_CHAR8, TK_STRING8, ACE_OutputCDR::from_char>(value, id);
 }

◆ get_char8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_char8_values	(	DDS::CharSeq &	value,
		DDS::MemberId	id
	)

Definition at line 3991 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_char_common()

template<TypeKind CharKind, TypeKind StringKind, typename FromCharT , typename CharT >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_char_common	(	CharT &	value,
		DDS::MemberId	id
	)

private

Definition at line 3128 of file DynamicDataImpl.cpp.

References ACE_ERROR, container_, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, read_basic_member(), DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value(), OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, and OpenDDS::XTypes::typekind_to_string().

 {
   const TypeKind tk = type_->get_kind();
   bool good = true;
   switch (tk) {
   case CharKind: {
     if (id != MEMBER_ID_INVALID) {
       good = false;
       break;
     }
     DataContainer::const_single_iterator it = container_.single_map_.find(id);
     if (it != container_.single_map_.end()) {
       FromCharT from_char = it->second.get<FromCharT>();
       value = from_char.val_;
     } else {
       FromCharT from_char('\0');
       container_.set_default_basic_value(from_char);
       value = from_char.val_;
     }
     break;
   }
   case StringKind: {
     FromCharT from_char('\0');
     good = read_basic_member(from_char, id);
     if (good) {
       value = from_char.val_;
     }
     break;
   }
   case TK_STRUCTURE: {
     FromCharT from_char('\0');
     good = get_value_from_struct<CharKind>(from_char, id);
     if (good) {
       value = from_char.val_;
     }
     break;
   }
   case TK_UNION: {
     FromCharT from_char('\0');
     good = get_value_from_union<CharKind>(from_char, id);
     if (good) {
       value = from_char.val_;
     }
     break;
   }
   case TK_SEQUENCE:
   case TK_ARRAY: {
     FromCharT from_char('\0');
     good = get_value_from_collection<CharKind>(from_char, id);
     if (good) {
       value = from_char.val_;
     }
     break;
   }
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_char_common:"
                  " Map is currently not supported\n"));
     }
     good = false;
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_char_common::"
                " Failed to read a value of type %C from a DynamicData object of type %C\n",
                typekind_to_string(CharKind), typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ get_complex_from_aggregated()

bool OpenDDS::XTypes::DynamicDataImpl::get_complex_from_aggregated	(	DDS::DynamicData_var &	value,
		DDS::MemberId	id,
		FoundStatus &	found_status
	)

private

Definition at line 3658 of file DynamicDataImpl.cpp.

References container_, DynamicDataImpl(), FOUND_IN_COMPLEX_MAP, FOUND_IN_NON_COMPLEX_MAP, OpenDDS::XTypes::get_base_type(), move_sequence_to_complex(), move_single_to_complex(), NOT_FOUND, DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by get_complex_from_struct(), and get_complex_from_union().

 {
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     value = DDS::DynamicData::_duplicate(complex_it->second);
     found_status = FOUND_IN_COMPLEX_MAP;
     return true;
   }
 
   DDS::DynamicTypeMember_var dtm;
   if (type_->get_member(dtm, id) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::DynamicType_var member_type = get_base_type(md->type());
   DynamicDataImpl* dd_impl = new DynamicDataImpl(member_type);
   DDS::DynamicData_var dd_var = dd_impl;
 
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     if (!move_single_to_complex(single_it, dd_impl)) {
       return false;
     }
     found_status = FOUND_IN_NON_COMPLEX_MAP;
   } else {
     DataContainer::const_sequence_iterator sequence_it = container_.sequence_map_.find(id);
     if (sequence_it != container_.sequence_map_.end()) {
       if (!move_sequence_to_complex(sequence_it, dd_impl)) {
         return false;
       }
       found_status = FOUND_IN_NON_COMPLEX_MAP;
     } else {
       found_status = NOT_FOUND;
     }
   }
   value = dd_var;
   return true;
 }

◆ get_complex_from_collection()

bool OpenDDS::XTypes::DynamicDataImpl::get_complex_from_collection	(	DDS::DynamicData_ptr &	value,
		DDS::MemberId	id
	)

private

Definition at line 3840 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataBase::bound_total(), container_, DynamicDataImpl(), insert_complex(), move_sequence_to_complex(), move_single_to_complex(), CORBA::release(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by get_complex_value().

 {
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     CORBA::release(value);
     value = DDS::DynamicData::_duplicate(complex_it->second);
     return true;
   }
 
   DDS::TypeDescriptor_var td;
   if (type_->get_descriptor(td) != DDS::RETCODE_OK) {
     return false;
   }
   if (type_->get_kind() == TK_ARRAY && id >= bound_total(td)) {
     return false;
   }
 
   DynamicDataImpl* dd_impl = new DynamicDataImpl(td->element_type());
   DDS::DynamicData_var dd_var = dd_impl;
 
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     if (!move_single_to_complex(single_it, dd_impl)) {
       return false;
     }
   } else {
     DataContainer::const_sequence_iterator sequence_it = container_.sequence_map_.find(id);
     if (sequence_it != container_.sequence_map_.end()) {
       if (!move_sequence_to_complex(sequence_it, dd_impl)) {
         return false;
       }
     }
   }
   insert_complex(id, dd_var);
   CORBA::release(value);
   value = DDS::DynamicData::_duplicate(dd_var);
   return true;
 }

◆ get_complex_from_struct()

bool OpenDDS::XTypes::DynamicDataImpl::get_complex_from_struct	(	DDS::DynamicData_ptr &	value,
		DDS::MemberId	id
	)

private

Definition at line 3701 of file DynamicDataImpl.cpp.

References FOUND_IN_NON_COMPLEX_MAP, get_complex_from_aggregated(), insert_complex(), NOT_FOUND, and CORBA::release().

Referenced by get_complex_value().

 {
   FoundStatus found_status = NOT_FOUND;
   DDS::DynamicData_var dd_var;
   if (!get_complex_from_aggregated(dd_var, id, found_status)) {
     return false;
   }
 
   if (found_status == FOUND_IN_NON_COMPLEX_MAP || found_status == NOT_FOUND) {
     insert_complex(id, dd_var);
   }
   CORBA::release(value);
   value = DDS::DynamicData::_duplicate(dd_var);
   return true;
 }

◆ get_complex_from_union()

bool OpenDDS::XTypes::DynamicDataImpl::get_complex_from_union	(	DDS::DynamicData_ptr &	value,
		DDS::MemberId	id
	)

private

Definition at line 3763 of file DynamicDataImpl.cpp.

References ACE_ERROR, clear_value_i(), container_, OpenDDS::XTypes::DISCRIMINATOR_ID, DynamicDataImpl(), FOUND_IN_NON_COMPLEX_MAP, OpenDDS::XTypes::get_base_type(), get_complex_from_aggregated(), insert_complex(), insert_valid_discriminator(), LM_NOTICE, OpenDDS::DCPS::log_level, NOT_FOUND, OpenDDS::DCPS::LogLevel::Notice, CORBA::release(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::select_union_member(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_discriminator_value(), OpenDDS::XTypes::DynamicDataBase::type_, and write_discriminator().

Referenced by get_complex_value().

 {
   FoundStatus found_status = NOT_FOUND;
   DDS::DynamicData_var dd_var;
   if (!get_complex_from_aggregated(dd_var, id, found_status)) {
     return false;
   }
   if (found_status != NOT_FOUND) {
     if (found_status == FOUND_IN_NON_COMPLEX_MAP) {
       insert_complex(id, dd_var);
     }
     CORBA::release(value);
     value = DDS::DynamicData::_duplicate(dd_var);
     return true;
   }
 
   // Requested member with the given Id is not present in the container.
   if (id == DISCRIMINATOR_ID) {
     DDS::TypeDescriptor_var td;
     if (type_->get_descriptor(td) != DDS::RETCODE_OK) {
       return false;
     }
     DDS::DynamicType_var disc_type = get_base_type(td->discriminator_type());
     CORBA::Long disc_value;
     if (!container_.set_default_discriminator_value(disc_value, disc_type)) {
       return false;
     }
     bool found_selected_member = false;
     DDS::MemberDescriptor_var selected_md;
     if (!container_.select_union_member(disc_value, found_selected_member, selected_md)) {
       return false;
     }
     DynamicDataImpl* dd_impl = new DynamicDataImpl(disc_type);
     DDS::DynamicData_var dd_var = dd_impl;
     dd_impl->write_discriminator(disc_value);
     insert_complex(DISCRIMINATOR_ID, dd_var);
     if (found_selected_member && !selected_md->is_optional()) {
       DDS::DynamicType_var selected_type = get_base_type(selected_md->type());
       if (clear_value_i(selected_md->id(), selected_type) != DDS::RETCODE_OK) {
         return false;
       }
     }
     CORBA::release(value);
     value = DDS::DynamicData::_duplicate(dd_var);
   } else {
     DataContainer::const_single_iterator single_it = container_.single_map_.find(DISCRIMINATOR_ID);
     DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(DISCRIMINATOR_ID);
     const bool has_disc = single_it != container_.single_map_.end() ||
       complex_it != container_.complex_map_.end();
     if (has_disc) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_complex_from_union:"
                    " Branch Id %u is not the active branch in the union\n", id));
       }
       return false;
     }
     DDS::DynamicTypeMember_var dtm;
     if (type_->get_member(dtm, id) != DDS::RETCODE_OK) {
       return false;
     }
     DDS::MemberDescriptor_var md;
     if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
       return false;
     }
     // An empty DynamicData object implicitly contains default value of the associated type.
     DynamicDataImpl* dd_impl = new DynamicDataImpl(md->type());
     DDS::DynamicData_var dd_var = dd_impl;
     if (!insert_valid_discriminator(md)) {
       return false;
     }
     insert_complex(id, dd_var);
     CORBA::release(value);
     value = DDS::DynamicData::_duplicate(dd_var);
   }
   return true;
 }

◆ get_complex_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_complex_value	(	DDS::DynamicData_ptr &	value,
		DDS::MemberId	id
	)

Definition at line 3879 of file DynamicDataImpl.cpp.

References ACE_ERROR, get_complex_from_collection(), get_complex_from_struct(), get_complex_from_union(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, and OpenDDS::XTypes::typekind_to_string().

 {
   const TypeKind tk = type_->get_kind();
   bool good = true;
   switch (tk) {
   case TK_STRUCTURE:
     good = get_complex_from_struct(value, id);
     break;
   case TK_UNION:
     good = get_complex_from_union(value, id);
     break;
   case TK_SEQUENCE:
   case TK_ARRAY:
     good = get_complex_from_collection(value, id);
     break;
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_complex_value:"
                  " Map is currently not supported\n"));
     }
     good = false;
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_complex_value:"
                " Failed to read a complex value from a DynamicData object of type %C\n",
                typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ get_float128_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float128_value	(	CORBA::LongDouble &	value,
		DDS::MemberId	id
	)

Definition at line 3122 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_FLOAT128>(value, id);
 }

◆ get_float128_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float128_values	(	DDS::Float128Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3984 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_float32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float32_value	(	CORBA::Float &	value,
		DDS::MemberId	id
	)

Definition at line 3112 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_FLOAT32>(value, id);
 }

◆ get_float32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float32_values	(	DDS::Float32Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3970 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_float64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float64_value	(	CORBA::Double &	value,
		DDS::MemberId	id
	)

Definition at line 3117 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_FLOAT64>(value, id);
 }

◆ get_float64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_float64_values	(	DDS::Float64Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3977 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_int16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int16_value	(	CORBA::Short &	value,
		DDS::MemberId	id
	)

Definition at line 3082 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_INT16>(value, id);
 }

◆ get_int16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int16_values	(	DDS::Int16Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3942 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_int32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int32_value	(	CORBA::Long &	value,
		DDS::MemberId	id
	)

Definition at line 3092 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_INT32>(value, id);
 }

◆ get_int32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int32_values	(	DDS::Int32Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3914 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_int64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int64_value	(	CORBA::LongLong &	value,
		DDS::MemberId	id
	)

Definition at line 3102 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_INT64>(value, id);
 }

◆ get_int64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int64_values	(	DDS::Int64Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3956 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_int8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int8_value	(	CORBA::Int8 &	value,
		DDS::MemberId	id
	)

Definition at line 3062 of file DynamicDataImpl.cpp.

References DDS::RETCODE_OK.

Referenced by read_basic_value().

 {
   ACE_OutputCDR::from_int8 from_int8(0);
   const DDS::ReturnCode_t rc = get_single_value<TK_INT8>(from_int8, id);
   if (rc == DDS::RETCODE_OK) {
     value = from_int8.val_;
   }
   return rc;
 }

◆ get_int8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_int8_values	(	DDS::Int8Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3928 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_item_count()

ACE_CDR::ULong OpenDDS::XTypes::DynamicDataImpl::get_item_count ( )

Implements DDS::DynamicData.

Definition at line 217 of file DynamicDataImpl.cpp.

Referenced by get_member_id_at_index().

 {
   const TypeKind tk = type_->get_kind();
   switch (tk) {
   case TK_BOOLEAN:
   case TK_BYTE:
   case TK_UINT8:
   case TK_UINT16:
   case TK_UINT32:
   case TK_UINT64:
   case TK_INT8:
   case TK_INT16:
   case TK_INT32:
   case TK_INT64:
   case TK_FLOAT32:
   case TK_FLOAT64:
   case TK_FLOAT128:
   case TK_CHAR8:
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
 #endif
   case TK_ENUM:
     return 1;
   case TK_STRING8:
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
 #endif
     {
       if (!container_.single_map_.empty() || !container_.complex_map_.empty()) {
         CORBA::ULong largest_index;
         if (!container_.get_largest_index_basic(largest_index)) {
           return 0;
         }
         return largest_index + 1;
       }
       return 0;
     }
   case TK_SEQUENCE:
     return get_sequence_size();
   case TK_BITMASK:
     return static_cast<ACE_CDR::ULong>(container_.single_map_.size() +
                                        container_.complex_map_.size());
   case TK_ARRAY: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       return 0;
     }
     return bound_total(descriptor);
   }
   case TK_STRUCTURE: {
     const CORBA::ULong member_count = type_->get_member_count();
     CORBA::ULong count = member_count;
     // An optional member that hasn't been set is considered missing.
     // All non-optional members are counted since they either are set directly
     // or hold default values (XTypes spec 7.5.2.11.6).
     for (CORBA::ULong i = 0; i < member_count; ++i) {
       DDS::DynamicTypeMember_var dtm;
       if (type_->get_member_by_index(dtm, i) != DDS::RETCODE_OK) {
         return 0;
       }
       DDS::MemberDescriptor_var md;
       if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
         return 0;
       }
       if (md->is_optional()) {
         const DDS::MemberId id = md->id();
         if (container_.single_map_.find(id) == container_.single_map_.end() &&
             container_.sequence_map_.find(id) == container_.sequence_map_.end() &&
             container_.complex_map_.find(id) == container_.complex_map_.end()) {
           --count;
         }
       }
     }
     return count;
   }
   case TK_UNION: {
     CORBA::ULong count = static_cast<CORBA::ULong>(container_.single_map_.size() +
                                                    container_.sequence_map_.size() +
                                                    container_.complex_map_.size());
     if (count > 0) {
       return count;
     }
     DDS::TypeDescriptor_var td;
     if (type_->get_descriptor(td) != DDS::RETCODE_OK) {
       return 0;
     }
     DDS::DynamicType_var disc_type = get_base_type(td->discriminator_type());
     CORBA::Long disc_val;
     if (!container_.set_default_discriminator_value(disc_val, disc_type)) {
       return 0;
     }
     bool select_a_member;
     DDS::MemberDescriptor_var selected_md;
     if (!container_.select_union_member(disc_val, select_a_member, selected_md)) {
       return 0;
     }
     return select_a_member ? 2 : 1;
   }
   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: DynamicDataImpl::get_item_count:"
                  " Encounter unexpected type kind %C\n", typekind_to_string(tk)));
     }
     return 0;
   }
 }

◆ get_member_id_at_index()

DDS::MemberId OpenDDS::XTypes::DynamicDataImpl::get_member_id_at_index ( ACE_CDR::ULong index )

Definition at line 58 of file DynamicDataImpl.cpp.

 {
   const TypeKind tk = type_->get_kind();
   switch (tk) {
   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:
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
 #endif
   case TK_ENUM:
     // Value of enum or primitive types can be indicated by Id MEMBER_ID_INVALID
     // or by index 0 (Section 7.5.2.11.1).
     if (index != 0 && DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_member_id_at_index:"
                  " Received invalid index (%u) for type %C\n", index, typekind_to_string(tk)));
     }
     return MEMBER_ID_INVALID;
   case TK_BITMASK:
     // TODO: Bitmask type needs improvement. See comments in set_single_value method.
     return MEMBER_ID_INVALID;
   case TK_STRING8:
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
 #endif
   case TK_SEQUENCE: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       return MEMBER_ID_INVALID;
     }
     const CORBA::ULong bound = descriptor->bound()[0];
     if (bound > 0 && index >= bound) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_member_id_at_index:"
                    " Input index (%u) is out-of-bound (bound is %u)\n", index, bound));
       }
       return MEMBER_ID_INVALID;
     }
     return index;
   }
   case TK_ARRAY: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       return MEMBER_ID_INVALID;
     }
     const CORBA::ULong length = bound_total(descriptor);
     if (index >= length) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_member_id_at_index:"
                    " Input index (%u) is out-of-bound (array length is %u)\n", index, length));
       }
       return MEMBER_ID_INVALID;
     }
     return index;
   }
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_member_id_at_index:"
                  " Map is currently not supported\n"));
     }
     return MEMBER_ID_INVALID;
   case TK_STRUCTURE:
     if (index < container_.single_map_.size()) {
       DataContainer::const_single_iterator it = container_.single_map_.begin();
       std::advance(it, index);
       return it->first;
     }
     if (index - container_.single_map_.size() < container_.sequence_map_.size()) {
       DataContainer::const_sequence_iterator it = container_.sequence_map_.begin();
       std::advance(it, index - container_.single_map_.size());
       return it->first;
     }
     if (index - container_.single_map_.size() - container_.sequence_map_.size() < container_.complex_map_.size()) {
       DataContainer::const_complex_iterator it = container_.complex_map_.begin();
       std::advance(it, index - container_.single_map_.size() - container_.sequence_map_.size());
       return it->first;
     }
     return MEMBER_ID_INVALID;
   case TK_UNION:
     if (index == 0) {
       return DISCRIMINATOR_ID;
     }
     if (index >= get_item_count()) {
       return MEMBER_ID_INVALID;
     }
     if (!container_.sequence_map_.empty()) {
       return container_.sequence_map_.begin()->first;
     }
     for (DataContainer::const_complex_iterator iter = container_.complex_map_.begin();
          iter != container_.complex_map_.end(); ++iter) {
       if (iter->first != DISCRIMINATOR_ID) {
         return iter->first;
       }
     }
     for (DataContainer::const_single_iterator iter = container_.single_map_.begin();
          iter != container_.single_map_.end(); ++iter) {
       if (iter->first != DISCRIMINATOR_ID) {
         return iter->first;
       }
     }
     return MEMBER_ID_INVALID;
   }
 
   if (DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_member_id_at_index:"
                " Calling on an unexpected type %C\n", typekind_to_string(tk)));
   }
   return MEMBER_ID_INVALID;
 }

◆ get_sequence_size()

CORBA::ULong OpenDDS::XTypes::DynamicDataImpl::get_sequence_size ( ) const

private

Definition at line 179 of file DynamicDataImpl.cpp.

References container_, OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_largest_index_basic(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_largest_sequence_index(), OpenDDS::XTypes::TK_SEQUENCE, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by clear_value(), and get_item_count().

 {
   if (type_->get_kind() != TK_SEQUENCE) {
     return 0;
   }
 
   if (!container_.single_map_.empty() || !container_.complex_map_.empty()) {
     CORBA::ULong largest_index;
     if (!container_.get_largest_index_basic(largest_index)) {
       return 0;
     }
     if (!container_.sequence_map_.empty()) {
       CORBA::ULong largest_seq_index;
       if (!container_.get_largest_sequence_index(largest_seq_index)) {
         return 0;
       }
       largest_index = std::max(largest_index, largest_seq_index);
     }
     return largest_index + 1;
   } else if (!container_.sequence_map_.empty()) {
     CORBA::ULong largest_index;
     if (!container_.get_largest_sequence_index(largest_index)) {
       return 0;
     }
     return largest_index + 1;
   }
   return 0;
 }

◆ get_simple_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value	(	DCPS::Value &	value,
		DDS::MemberId	id
	)

virtual

Implements OpenDDS::XTypes::DynamicDataBase.

Definition at line 2064 of file DynamicDataImpl.cpp.

References ACE_ERROR, OpenDDS::XTypes::get_base_type(), get_simple_value_boolean(), get_simple_value_char(), get_simple_value_enum(), get_simple_value_string(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_CHAR8, OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::TK_FLOAT128, OpenDDS::XTypes::TK_FLOAT64, OpenDDS::XTypes::TK_INT32, OpenDDS::XTypes::TK_INT64, OpenDDS::XTypes::TK_STRING8, OpenDDS::XTypes::TK_UINT32, OpenDDS::XTypes::TK_UINT64, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and value.

 {
   DDS::DynamicTypeMember_var dtm;
   if (type_->get_member(dtm, id) != DDS::RETCODE_OK) {
     return DDS::RETCODE_ERROR;
   }
   DDS::MemberDescriptor_var md;
   if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
     return DDS::RETCODE_ERROR;
   }
   DDS::DynamicType_var member_type = get_base_type(md->type());
   const TypeKind member_kind = member_type->get_kind();
   switch (member_kind) {
   case TK_BOOLEAN:
     return get_simple_value_boolean(value, id);
   case TK_INT32:
     return get_simple_value_primitive<CORBA::Long>(value, id);
   case TK_UINT32:
     return get_simple_value_primitive<CORBA::ULong>(value, id);
   case TK_INT64:
     return get_simple_value_primitive<CORBA::LongLong>(value, id);
   case TK_UINT64:
     return get_simple_value_primitive<CORBA::ULongLong>(value, id);
   case TK_CHAR8:
     return get_simple_value_char(value, id);
   case TK_FLOAT64:
     return get_simple_value_primitive<CORBA::Double>(value, id);
   case TK_FLOAT128:
     return get_simple_value_primitive<CORBA::LongDouble>(value, id);
   case TK_STRING8:
     return get_simple_value_string(value, id);
   case TK_ENUM:
     return get_simple_value_enum(value, id);
   default:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_simple_value:"
                  " Member type %C is not supported by DCPS::Value\n",
                  typekind_to_string(member_kind)));
     }
   }
   return DDS::RETCODE_ERROR;
 }

◆ get_simple_value_boolean()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value_boolean	(	DCPS::Value &	value,
		DDS::MemberId	id
	)		const

private

Definition at line 1943 of file DynamicDataImpl.cpp.

References container_, OpenDDS::DCPS::Value::get(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_ERROR, and DDS::RETCODE_OK.

Referenced by get_simple_value().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     value = single_it->second.get<ACE_OutputCDR::from_boolean>().val_;
     return DDS::RETCODE_OK;
   }
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     const DynamicDataImpl* inner_dd = dynamic_cast<DynamicDataImpl*>(complex_it->second.in());
     if (!inner_dd) {
       return DDS::RETCODE_ERROR;
     }
     DataContainer::const_single_iterator inner_it =
       inner_dd->container_.single_map_.find(MEMBER_ID_INVALID);
     if (inner_it != inner_dd->container_.single_map_.end()) {
       value = inner_it->second.get<ACE_OutputCDR::from_boolean>().val_;
       return DDS::RETCODE_OK;
     }
   }
   return DDS::RETCODE_ERROR;
 }

◆ get_simple_value_char()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value_char	(	DCPS::Value &	value,
		DDS::MemberId	id
	)		const

private

Definition at line 1967 of file DynamicDataImpl.cpp.

References container_, OpenDDS::DCPS::Value::get(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_ERROR, and DDS::RETCODE_OK.

Referenced by get_simple_value().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     value = single_it->second.get<ACE_OutputCDR::from_char>().val_;
     return DDS::RETCODE_OK;
   }
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     const DynamicDataImpl* inner_dd = dynamic_cast<DynamicDataImpl*>(complex_it->second.in());
     if (!inner_dd) {
       return DDS::RETCODE_ERROR;
     }
     DataContainer::const_single_iterator inner_it =
       inner_dd->container_.single_map_.find(MEMBER_ID_INVALID);
     if (inner_it != inner_dd->container_.single_map_.end()) {
       value = inner_it->second.get<ACE_OutputCDR::from_char>().val_;
       return DDS::RETCODE_OK;
     }
   }
   return DDS::RETCODE_ERROR;
 }

◆ get_simple_value_enum()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value_enum	(	DCPS::Value &	value,
		DDS::MemberId	id
	)		const

private

Definition at line 2039 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::get_enum_value(), OpenDDS::XTypes::get_enumerator_name(), OpenDDS::XTypes::get_member_type(), OpenDDS::XTypes::DynamicDataBase::interface_from_this(), DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by get_simple_value().

 {
   DDS::DynamicType_var mtype;
   DDS::ReturnCode_t ret = get_member_type(mtype, type_, id);
   if (ret != DDS::RETCODE_OK) {
     return ret;
   }
 
   DDS::Int32 enumAsInteger;
   ret = get_enum_value(enumAsInteger, mtype, interface_from_this(), id);
   if (ret != DDS::RETCODE_OK) {
     return ret;
   }
 
   DDS::String8_var str;
   ret = get_enumerator_name(str, enumAsInteger, mtype);
   if (ret != DDS::RETCODE_OK) {
     return ret;
   }
 
   value = str.in();
   return DDS::RETCODE_OK;
 }

◆ get_simple_value_primitive()

template<typename ValueType >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value_primitive	(	DCPS::Value &	value,
		DDS::MemberId	id
	)		const

private

Definition at line 1992 of file DynamicDataImpl.cpp.

References container_, OpenDDS::DCPS::Value::get(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_ERROR, and DDS::RETCODE_OK.

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     value = single_it->second.get<ValueType>();
     return DDS::RETCODE_OK;
   }
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     const DynamicDataImpl* inner_dd = dynamic_cast<DynamicDataImpl*>(complex_it->second.in());
     if (!inner_dd) {
       return DDS::RETCODE_ERROR;
     }
     DataContainer::const_single_iterator inner_it =
       inner_dd->container_.single_map_.find(MEMBER_ID_INVALID);
     if (inner_it != inner_dd->container_.single_map_.end()) {
       value = inner_it->second.get<ValueType>();
       return DDS::RETCODE_OK;
     }
   }
   return DDS::RETCODE_ERROR;
 }

◆ get_simple_value_string()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_simple_value_string	(	DCPS::Value &	value,
		DDS::MemberId	id
	)		const

private

Definition at line 2016 of file DynamicDataImpl.cpp.

References container_, OpenDDS::DCPS::Value::get(), read_basic_value(), DDS::RETCODE_ERROR, and DDS::RETCODE_OK.

Referenced by get_simple_value().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     value = single_it->second.get<const char*>();
     return DDS::RETCODE_OK;
   }
 
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     // The string member has its own DynamicData object.
     const DynamicDataImpl* str_dd = dynamic_cast<DynamicDataImpl*>(complex_it->second.in());
     char* str = 0;
     if (!str_dd || !str_dd->read_basic_value(str)) {
       return DDS::RETCODE_ERROR;
     }
     value = str;
     return DDS::RETCODE_OK;
   }
   return DDS::RETCODE_ERROR;
 }

◆ get_single_value()

template<TypeKind ValueTypeKind, typename ValueType >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_single_value	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 3014 of file DynamicDataImpl.cpp.

References ACE_ERROR, get_value_from_self(), OpenDDS::XTypes::DynamicDataBase::is_type_supported(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_BITMASK, OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and value.

 {
   if (!is_type_supported(ValueTypeKind, "get_single_value")) {
     return DDS::RETCODE_ERROR;
   }
   const TypeKind tk = type_->get_kind();
   bool good = true;
 
   switch (tk) {
   case ValueTypeKind:
     good = get_value_from_self(value, id);
     break;
   case TK_ENUM:
     good = get_value_from_enum<ValueTypeKind>(value, id);
     break;
   case TK_BITMASK:
     good = get_value_from_bitmask<ValueTypeKind>(value, id);
     break;
   case TK_STRUCTURE:
     good = get_value_from_struct<ValueTypeKind>(value, id);
     break;
   case TK_UNION:
     good = get_value_from_union<ValueTypeKind>(value, id);
     break;
   case TK_SEQUENCE:
   case TK_ARRAY:
     good = get_value_from_collection<ValueTypeKind>(value, id);
     break;
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_single_value:"
                  " Map is currently not supported\n"));
     }
     good = false;
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_single_value:"
                " Failed to read a value of type %C from a DynamicData object of type %C\n",
                typekind_to_string(ValueTypeKind), typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ get_string_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_string_value	(	char *&	value,
		DDS::MemberId	id
	)

Definition at line 3337 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataBase::enum_string_helper(), DDS::RETCODE_OK, and value.

 {
   if (enum_string_helper(value, id)) {
     return DDS::RETCODE_OK;
   }
 
   return get_single_value<TK_STRING8>(value, id);
 }

◆ get_string_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_string_values	(	DDS::StringSeq &	value,
		DDS::MemberId	id
	)

Definition at line 4019 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_uint16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint16_value	(	CORBA::UShort &	value,
		DDS::MemberId	id
	)

Definition at line 3087 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_UINT16>(value, id);
 }

◆ get_uint16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint16_values	(	DDS::UInt16Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3949 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_uint32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint32_value	(	CORBA::ULong &	value,
		DDS::MemberId	id
	)

Definition at line 3097 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_UINT32>(value, id);
 }

◆ get_uint32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint32_values	(	DDS::UInt32Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3921 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_uint64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint64_value	(	CORBA::ULongLong &	value,
		DDS::MemberId	id
	)

Definition at line 3107 of file DynamicDataImpl.cpp.

References value.

Referenced by read_basic_value().

 {
   return get_single_value<TK_UINT64>(value, id);
 }

◆ get_uint64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint64_values	(	DDS::UInt64Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3963 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_uint8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint8_value	(	CORBA::UInt8 &	value,
		DDS::MemberId	id
	)

Definition at line 3072 of file DynamicDataImpl.cpp.

References DDS::RETCODE_OK.

Referenced by read_basic_value().

 {
   ACE_OutputCDR::from_uint8 from_uint8(0);
   const DDS::ReturnCode_t rc = get_single_value<TK_UINT8>(from_uint8, id);
   if (rc == DDS::RETCODE_OK) {
     value = from_uint8.val_;
   }
   return rc;
 }

◆ get_uint8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_uint8_values	(	DDS::UInt8Seq &	value,
		DDS::MemberId	id
	)

Definition at line 3935 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ get_value_from_bitmask() [1/3]

template<TypeKind ValueTypeKind, typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_bitmask	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2829 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::bitmask_bound(), container_, OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_bitmask_value(), and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   // Allow bitmask to be read as an unsigned integer.
   TypeKind treat_as_tk;
   const DDS::ReturnCode_t rc = bitmask_bound(type_, treat_as_tk);
   if (rc != DDS::RETCODE_OK || treat_as_tk != ValueTypeKind || id != MEMBER_ID_INVALID) {
     return false;
   }
   DataContainer::const_single_iterator it = container_.single_map_.find(MEMBER_ID_INVALID);
   if (it != container_.single_map_.end()) {
     value = it->second.get<ValueType>();
   } else {
     container_.set_default_bitmask_value(value);
   }
   return true;
 }

◆ get_value_from_bitmask() [2/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_bitmask	(	char *&	,
		DDS::MemberId
	)

private

Definition at line 2847 of file DynamicDataImpl.cpp.

 {
   return false;
 }

◆ get_value_from_bitmask() [3/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_bitmask	(	CORBA::WChar *&	,
		DDS::MemberId
	)

private

Definition at line 2852 of file DynamicDataImpl.cpp.

 {
   return false;
 }

◆ get_value_from_collection()

template<TypeKind ValueTypeKind, typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_collection	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2972 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::bitmask_bound(), OpenDDS::XTypes::DynamicDataBase::bound_total(), container_, OpenDDS::XTypes::enum_bound(), OpenDDS::XTypes::get_base_type(), insert_single(), read_basic_member(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value(), OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_BITMASK, OpenDDS::XTypes::TK_ENUM, and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
   if (type_->get_kind() == TK_ARRAY && id >= bound_total(descriptor)) {
     return false;
   }
 
   DDS::DynamicType_var elem_type = get_base_type(descriptor->element_type());
   const TypeKind elem_tk = elem_type->get_kind();
   TypeKind treat_as_tk = elem_tk;
   switch (elem_tk) {
   case TK_ENUM:
     if (enum_bound(elem_type, treat_as_tk) != DDS::RETCODE_OK) {
       return false;
     }
     break;
   case TK_BITMASK: {
     if (bitmask_bound(elem_type, treat_as_tk) != DDS::RETCODE_OK) {
       return false;
     }
     break;
   }
   }
   if (treat_as_tk != ValueTypeKind) {
     return false;
   }
   if (read_basic_member(value, id)) {
     return true;
   }
   container_.set_default_basic_value(value);
 
   // Must insert this member in case it's index is larger than the current largest index,
   // so that all new members up to this member are serialized. Otherwise, we would be returning
   // a value that wouldn't be in the serialized data.
   insert_single(id, value);
   return true;
 }

◆ get_value_from_enum() [1/3]

template<TypeKind ValueTypeKind, typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_enum	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2797 of file DynamicDataImpl.cpp.

References cast_to_enum_value(), container_, OpenDDS::XTypes::enum_bound(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_enum_value(), and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   TypeKind treat_as_tk;
   const DDS::ReturnCode_t rc = enum_bound(type_, treat_as_tk);
   if (rc != DDS::RETCODE_OK || treat_as_tk != ValueTypeKind || id != MEMBER_ID_INVALID) {
     return false;
   }
   DataContainer::const_single_iterator it = container_.single_map_.find(MEMBER_ID_INVALID);
   if (it != container_.single_map_.end()) {
     value = it->second.get<ValueType>();
   } else {
     CORBA::Long enum_default_val;
     if (!container_.set_default_enum_value(type_, enum_default_val)) {
       return false;
     }
     cast_to_enum_value(value, enum_default_val);
   }
   return true;
 }

◆ get_value_from_enum() [2/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_enum	(	char *&	,
		DDS::MemberId
	)

private

Definition at line 2818 of file DynamicDataImpl.cpp.

 {
   return false;
 }

◆ get_value_from_enum() [3/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_enum	(	CORBA::WChar *&	,
		DDS::MemberId
	)

private

Definition at line 2823 of file DynamicDataImpl.cpp.

 {
   return false;
 }

◆ get_value_from_self() [1/3]

template<typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_self	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2767 of file DynamicDataImpl.cpp.

References container_, OpenDDS::XTypes::DynamicDataBase::is_primitive(), OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value(), and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by get_single_value().

 {
   // Primitive or enum value can be read using MEMBER_ID_INVALID.
   if (!is_primitive(type_->get_kind()) || id != MEMBER_ID_INVALID) {
     return false;
   }
   DataContainer::const_single_iterator it = container_.single_map_.find(MEMBER_ID_INVALID);
   if (it != container_.single_map_.end()) {
     value = it->second.get<ValueType>();
   } else {
     container_.set_default_basic_value(value);
   }
   return true;
 }

◆ get_value_from_self() [2/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_self	(	char *&	,
		DDS::MemberId
	)

Definition at line 2783 of file DynamicDataImpl.cpp.

 {
   // Can't read a string from a DynamicData instance representing a string.
   return false;
 }

◆ get_value_from_self() [3/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_self	(	CORBA::WChar *&	,
		DDS::MemberId
	)

Definition at line 2790 of file DynamicDataImpl.cpp.

 {
   // Can't read a wstring from a DynamicData instance representing a wstring.
   return false;
 }

◆ get_value_from_struct()

template<TypeKind ValueTypeKind, typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_struct	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2858 of file DynamicDataImpl.cpp.

References ACE_ERROR, OpenDDS::XTypes::DynamicDataBase::check_member(), container_, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, read_basic_member(), DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value().

 {
   DDS::MemberDescriptor_var md;
   DDS::DynamicType_var member_type;
   DDS::ReturnCode_t rc = check_member(
     md, member_type, "DynamicDataImpl::get_value_from_struct", "get", id, ValueTypeKind);
   if (rc != DDS::RETCODE_OK) {
     return false;
   }
   if (read_basic_member(value, id)) {
     return true;
   }
 
   // Not returning a default value for a missing optional member.
   if (md->is_optional()) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_value_from_struct:"
                  " Optional member Id %u is not present\n", id));
     }
     return false;
   }
   container_.set_default_basic_value(value);
   return true;
 }

◆ get_value_from_union()

template<TypeKind ValueTypeKind, typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::get_value_from_union	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2884 of file DynamicDataImpl.cpp.

References ACE_ERROR, cast_to_discriminator_value(), OpenDDS::XTypes::DynamicDataBase::check_member(), clear_value_i(), container_, OpenDDS::XTypes::DISCRIMINATOR_ID, OpenDDS::XTypes::get_base_type(), insert_single(), insert_valid_discriminator(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, OPENDDS_ASSERT, read_basic_in_single_map(), read_basic_member(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataImpl::DataContainer::select_union_member(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_default_basic_value(), and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   DDS::MemberDescriptor_var md;
   DDS::DynamicType_var member_type;
   DDS::ReturnCode_t rc = check_member(
     md, member_type, "DynamicDataImpl::get_value_from_union", "get", id, ValueTypeKind);
   if (rc != DDS::RETCODE_OK) {
     return false;
   }
 
   // Return the member if it is in the container.
   if (read_basic_member(value, id)) {
     return true;
   }
 
   if (id == DISCRIMINATOR_ID) {
     // Set the discriminator to default value.
     // If it selects a branch, set the branch to default value.
     container_.set_default_basic_value(value);
     CORBA::Long disc_value;
     if (!cast_to_discriminator_value(disc_value, value)) {
       return false;
     }
     bool found_selected_member = false;
     DDS::MemberDescriptor_var selected_md;
     if (!container_.select_union_member(disc_value, found_selected_member, selected_md)) {
       return false;
     }
     insert_single(id, value);
     if (found_selected_member && !selected_md->is_optional()) {
       DDS::DynamicType_var selected_type = get_base_type(selected_md->type());
       if (clear_value_i(selected_md->id(), selected_type) != DDS::RETCODE_OK) {
         return false;
       }
     }
   } else {
     DataContainer::const_single_iterator single_it = container_.single_map_.find(DISCRIMINATOR_ID);
     DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(DISCRIMINATOR_ID);
     const bool has_disc = single_it != container_.single_map_.end() ||
       complex_it != container_.complex_map_.end();
     if (has_disc) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::get_value_from_union:"
                    " Branch Id %u is not the active branch in the union\n", id));
       }
       return false;
     }
     // Set the branch to default value and set the discriminator to a value that selects this branch.
     DDS::DynamicTypeMember_var dtm;
     if (type_->get_member(dtm, id) != DDS::RETCODE_OK) {
       return false;
     }
     DDS::MemberDescriptor_var md;
     if (dtm->get_descriptor(md) != DDS::RETCODE_OK) {
       return false;
     }
     DDS::DynamicType_var dt = get_base_type(md->type());
     if (clear_value_i(id, dt) != DDS::RETCODE_OK) {
       return false;
     }
     if (!insert_valid_discriminator(md)) {
       return false;
     }
     OPENDDS_ASSERT(read_basic_in_single_map(value, id));
   }
   return true;
 }

◆ get_wstring_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_wstring_value	(	CORBA::WChar *&	value,
		DDS::MemberId	id
	)

Definition at line 3346 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED, and value.

 {
 #ifdef DDS_HAS_WCHAR
   return get_single_value<TK_STRING16>(value, id);
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ get_wstring_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::get_wstring_values	(	DDS::WstringSeq &	value,
		DDS::MemberId	id
	)

Definition at line 4026 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   ACE_UNUSED_ARG(value);
   ACE_UNUSED_ARG(id);
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ insert_complex()

bool OpenDDS::XTypes::DynamicDataImpl::insert_complex	(	DDS::MemberId	id,
		const DDS::DynamicData_var &	value
	)

private

Definition at line 719 of file DynamicDataImpl.cpp.

References container_.

Referenced by clear_value_i(), get_complex_from_collection(), get_complex_from_struct(), get_complex_from_union(), set_complex_to_collection(), set_complex_to_struct(), and set_complex_to_union().

 {
   if (container_.single_map_.erase(id) == 0) {
     if (container_.sequence_map_.erase(id) == 0) {
       container_.complex_map_.erase(id);
     }
   }
   return container_.complex_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_discriminator()

bool OpenDDS::XTypes::DynamicDataImpl::insert_discriminator ( ACE_CDR::Long value )

private

Definition at line 1587 of file DynamicDataImpl.cpp.

Referenced by insert_valid_discriminator().

 {
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, DISCRIMINATOR_ID) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var descriptor;
   if (member->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::DynamicType_var discType = get_base_type(descriptor->type());
   switch (discType ? discType->get_kind() : TK_NONE) {
   case TK_BOOLEAN:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_boolean(value));
   case TK_BYTE:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_octet(value));
   case TK_CHAR8:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_char(value));
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_wchar(value));
 #endif
   case TK_INT8:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_int8(value));
   case TK_UINT8:
     return insert_single(DISCRIMINATOR_ID, ACE_OutputCDR::from_uint8(value));
   case TK_INT16:
     return insert_single(DISCRIMINATOR_ID, static_cast<ACE_CDR::Short>(value));
   case TK_UINT16:
     return insert_single(DISCRIMINATOR_ID, static_cast<ACE_CDR::UShort>(value));
   case TK_ENUM:
   case TK_INT32:
     return insert_single(DISCRIMINATOR_ID, value);
   case TK_UINT32:
     return insert_single(DISCRIMINATOR_ID, static_cast<ACE_CDR::ULong>(value));
   case TK_INT64:
     return insert_single(DISCRIMINATOR_ID, static_cast<ACE_CDR::LongLong>(value));
   case TK_UINT64:
     return insert_single(DISCRIMINATOR_ID, static_cast<ACE_CDR::ULongLong>(value));
   default:
     return false;
   }
 }

◆ insert_sequence()

template<typename SequenceType >

bool OpenDDS::XTypes::DynamicDataImpl::insert_sequence	(	DDS::MemberId	id,
		const SequenceType &	value
	)

private

Definition at line 2273 of file DynamicDataImpl.cpp.

References container_.

Referenced by set_values_to_array(), set_values_to_sequence(), set_values_to_struct(), and set_values_to_union().

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.sequence_map_.erase(id);
   }
   return container_.sequence_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [1/6]

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const ACE_OutputCDR::from_int8 &	value
	)

private

Definition at line 658 of file DynamicDataImpl.cpp.

References container_.

Referenced by clear_value_i(), get_value_from_collection(), get_value_from_union(), insert_discriminator(), insert_single(), move_sequence_helper(), move_single_to_complex_i(), set_boolean_value(), set_char_common(), set_single_value(), set_value_to_collection(), set_value_to_struct(), set_value_to_union(), and write_discriminator_helper().

 {
   // The same member might be already written to complex_map_.
   // Make sure there is only one entry for each member.
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [2/6]

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const ACE_OutputCDR::from_uint8 &	value
	)

private

Definition at line 668 of file DynamicDataImpl.cpp.

References container_.

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [3/6]

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const ACE_OutputCDR::from_char &	value
	)

private

Definition at line 676 of file DynamicDataImpl.cpp.

References container_.

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [4/6]

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const ACE_OutputCDR::from_octet &	value
	)

private

Definition at line 684 of file DynamicDataImpl.cpp.

References container_.

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [5/6]

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const ACE_OutputCDR::from_boolean &	value
	)

private

Definition at line 692 of file DynamicDataImpl.cpp.

References container_, insert_single(), and value.

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_single() [6/6]

template<typename SingleType >

bool OpenDDS::XTypes::DynamicDataImpl::insert_single	(	DDS::MemberId	id,
		const SingleType &	value
	)

private

Definition at line 711 of file DynamicDataImpl.cpp.

References container_.

 {
   if (container_.complex_map_.erase(id) == 0) {
     container_.single_map_.erase(id);
   }
   return container_.single_map_.insert(std::make_pair(id, value)).second;
 }

◆ insert_valid_discriminator()

bool OpenDDS::XTypes::DynamicDataImpl::insert_valid_discriminator ( DDS::MemberDescriptor * memberSelected )

private

Definition at line 1558 of file DynamicDataImpl.cpp.

References OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::add(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), OpenDDS::XTypes::DISCRIMINATOR_ID, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), DDS::MemberDescriptor::id, insert_discriminator(), DDS::MemberDescriptor::is_default_label, DDS::MemberDescriptor::label, OpenDDS::XTypes::Sequence< T >::length(), DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by get_complex_from_union(), get_value_from_union(), set_complex_to_union(), set_value_to_union(), and set_values_to_union().

 {
   if (memberSelected->is_default_label()) {
     DCPS::DisjointSequence::OrderedRanges<ACE_CDR::Long> used;
     const ACE_CDR::ULong members = type_->get_member_count();
     for (ACE_CDR::ULong i = 0; i < members; ++i) {
       DDS::DynamicTypeMember_var member;
       if (type_->get_member_by_index(member, i) != DDS::RETCODE_OK) {
         return false;
       }
       if (member->get_id() == DISCRIMINATOR_ID || member->get_id() == memberSelected->id()) {
         continue;
       }
       DDS::MemberDescriptor_var mdesc;
       if (member->get_descriptor(mdesc) != DDS::RETCODE_OK) {
         return false;
       }
       const DDS::UnionCaseLabelSeq& lseq = mdesc->label();
       for (ACE_CDR::ULong lbl = 0; lbl < lseq.length(); ++lbl) {
         used.add(lseq[lbl]);
       }
     }
     const ACE_CDR::Long disc = used.empty() ? 0 : used.begin()->second + 1;
     return insert_discriminator(disc);
   }
   const DDS::UnionCaseLabelSeq& lseq = memberSelected->label();
   return lseq.length() && insert_discriminator(lseq[0]);
 }

◆ is_default_member_selected()

bool OpenDDS::XTypes::DynamicDataImpl::is_default_member_selected	(	CORBA::Long	disc_val,
		DDS::MemberId	default_id
	)		const

private

Definition at line 769 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicTypeMembersByIdImpl::begin(), OpenDDS::XTypes::DynamicTypeMembersByIdImpl::end(), OpenDDS::XTypes::Sequence< T >::length(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_UNION, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by validate_discriminator().

 {
   if (type_->get_kind() != TK_UNION) {
     return false;
   }
 
   DDS::DynamicTypeMembersById_var members_var;
   if (type_->get_all_members(members_var) != DDS::RETCODE_OK) {
     return false;
   }
   DynamicTypeMembersByIdImpl* members = dynamic_cast<DynamicTypeMembersByIdImpl*>(members_var.in());
   if (!members) {
     return false;
   }
 
   for (DynamicTypeMembersByIdImpl::const_iterator it = members->begin(); it != members->end(); ++it) {
     if (it->first == default_id) continue;
 
     DDS::MemberDescriptor_var md;
     if (it->second->get_descriptor(md) != DDS::RETCODE_OK) {
       return false;
     }
     const DDS::UnionCaseLabelSeq& labels = md->label();
     for (CORBA::ULong i = 0; i < labels.length(); ++i) {
       if (disc_val == labels[i]) {
         return false;
       }
     }
   }
   return true;
 }

◆ is_valid_discriminator_type()

bool OpenDDS::XTypes::DynamicDataImpl::is_valid_discriminator_type ( TypeKind tk )

staticprivate

Definition at line 744 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_BYTE, OpenDDS::XTypes::TK_CHAR16, OpenDDS::XTypes::TK_CHAR8, OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::TK_INT16, OpenDDS::XTypes::TK_INT32, OpenDDS::XTypes::TK_INT64, OpenDDS::XTypes::TK_INT8, OpenDDS::XTypes::TK_UINT16, OpenDDS::XTypes::TK_UINT32, OpenDDS::XTypes::TK_UINT64, and OpenDDS::XTypes::TK_UINT8.

Referenced by read_discriminator(), and set_value_to_union().

 {
   switch (tk) {
   case TK_BOOLEAN:
   case TK_BYTE:
   case TK_CHAR8:
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
 #endif
   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_ENUM:
     return true;
   default:
     return false;
   }
 }

◆ loan_value()

DDS::DynamicData_ptr OpenDDS::XTypes::DynamicDataImpl::loan_value ( DDS::MemberId id )

Definition at line 641 of file DynamicDataImpl.cpp.

References ACE_ERROR, and LM_ERROR.

 {
   ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: DynamicDataImpl::loan_value: Not implemented\n"));
   return 0;
 }

◆ move_sequence_helper()

template<typename SequenceType >

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

private

Definition at line 3475 of file DynamicDataImpl.cpp.

References insert_single().

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

◆ move_sequence_to_complex()

bool OpenDDS::XTypes::DynamicDataImpl::move_sequence_to_complex	(	const DataContainer::const_sequence_iterator &	it,
		DynamicDataImpl *	data
	)

private

Definition at line 3569 of file DynamicDataImpl.cpp.

Referenced by get_complex_from_aggregated(), and get_complex_from_collection().

 {
   DDS::DynamicType_var seq_type = data->type();
   DDS::TypeDescriptor_var seq_td;
   if (seq_type->get_descriptor(seq_td) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::DynamicType_var elem_type = get_base_type(seq_td->element_type());
 
   switch (elem_type->get_kind()) {
   case TK_INT8: {
     move_sequence_helper<DDS::Int8Seq>(it, data);
     break;
   }
   case TK_UINT8: {
     move_sequence_helper<DDS::UInt8Seq>(it, data);
     break;
   }
   case TK_INT16: {
     move_sequence_helper<DDS::Int16Seq>(it, data);
     break;
   }
   case TK_UINT16: {
     move_sequence_helper<DDS::UInt16Seq>(it, data);
     break;
   }
   case TK_INT32: {
     move_sequence_helper<DDS::Int32Seq>(it, data);
     break;
   }
   case TK_UINT32: {
     move_sequence_helper<DDS::UInt32Seq>(it, data);
     break;
   }
   case TK_INT64: {
     move_sequence_helper<DDS::Int64Seq>(it, data);
     break;
   }
   case TK_UINT64: {
     move_sequence_helper<DDS::UInt64Seq>(it, data);
     break;
   }
   case TK_FLOAT32: {
     move_sequence_helper<DDS::Float32Seq>(it, data);
     break;
   }
   case TK_FLOAT64: {
     move_sequence_helper<DDS::Float64Seq>(it, data);
     break;
   }
   case TK_FLOAT128: {
     move_sequence_helper<DDS::Float128Seq>(it, data);
     break;
   }
   case TK_CHAR8: {
     move_sequence_helper<DDS::CharSeq>(it, data);
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16: {
     move_sequence_helper<DDS::WcharSeq>(it, data);
     break;
   }
 #endif
   case TK_BYTE: {
     move_sequence_helper<DDS::ByteSeq>(it, data);
     break;
   }
   case TK_BOOLEAN: {
     move_sequence_helper<DDS::BooleanSeq>(it, data);
     break;
   }
   case TK_STRING8: {
     move_sequence_helper<DDS::StringSeq>(it, data);
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16: {
     move_sequence_helper<DDS::WstringSeq>(it, data);
     break;
   }
 #endif
   default:
     return false;
   }
   return true;
 }

◆ move_single_to_complex()

bool OpenDDS::XTypes::DynamicDataImpl::move_single_to_complex	(	const DataContainer::const_single_iterator &	it,
		DynamicDataImpl *	data
	)

private

Definition at line 3355 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::enum_bound(), move_single_to_complex_i(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_ENUM, and type().

Referenced by get_complex_from_aggregated(), and get_complex_from_collection().

 {
   DDS::DynamicType_var member_type = data->type();
   const TypeKind member_tk = member_type->get_kind();
   TypeKind treat_as = member_tk;
   if (member_tk == TK_ENUM) {
     if (enum_bound(member_type, treat_as) != DDS::RETCODE_OK) {
       return false;
     }
   }
   return move_single_to_complex_i(it, data, treat_as);
 }

◆ move_single_to_complex_i()

bool OpenDDS::XTypes::DynamicDataImpl::move_single_to_complex_i	(	const DataContainer::const_single_iterator &	it,
		DynamicDataImpl *	data,
		const TypeKind	treat_as
	)

private

Definition at line 3369 of file DynamicDataImpl.cpp.

Referenced by move_single_to_complex().

 {
   switch (treat_as) {
   case TK_INT8: {
     const ACE_OutputCDR::from_int8& value = it->second.get<ACE_OutputCDR::from_int8>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_UINT8: {
     const ACE_OutputCDR::from_uint8& value = it->second.get<ACE_OutputCDR::from_uint8>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_INT16: {
     const CORBA::Short value = it->second.get<CORBA::Short>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_UINT16: {
     const CORBA::UShort value = it->second.get<CORBA::UShort>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_INT32: {
     const CORBA::Long value = it->second.get<CORBA::Long>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_UINT32: {
     const CORBA::ULong value = it->second.get<CORBA::ULong>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_INT64: {
     const CORBA::LongLong value = it->second.get<CORBA::LongLong>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_UINT64: {
     const CORBA::ULongLong value = it->second.get<CORBA::ULongLong>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_FLOAT32: {
     const CORBA::Float value = it->second.get<CORBA::Float>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_FLOAT64: {
     const CORBA::Double value = it->second.get<CORBA::Double>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_FLOAT128: {
     const CORBA::LongDouble value = it->second.get<CORBA::LongDouble>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_CHAR8: {
     const ACE_OutputCDR::from_char& value = it->second.get<ACE_OutputCDR::from_char>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16: {
     const ACE_OutputCDR::from_wchar& value = it->second.get<ACE_OutputCDR::from_wchar>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
 #endif
   case TK_BYTE: {
     const ACE_OutputCDR::from_octet& value = it->second.get<ACE_OutputCDR::from_octet>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_BOOLEAN: {
     const ACE_OutputCDR::from_boolean& value = it->second.get<ACE_OutputCDR::from_boolean>();
     data->insert_single(MEMBER_ID_INVALID, value);
     break;
   }
   case TK_STRING8: {
     const char* str = it->second.get<const char*>();
     const size_t len = ACE_OS::strlen(str);
     for (CORBA::ULong i = 0; i < len; ++i) {
       data->insert_single(i, ACE_OutputCDR::from_char(str[i]));
     }
     break;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16: {
     const CORBA::WChar* wstr = it->second.get<const CORBA::WChar*>();
     const size_t len = ACE_OS::strlen(wstr);
     for (CORBA::ULong i = 0; i < len; ++i) {
       data->insert_single(i, ACE_OutputCDR::from_wchar(wstr[i]));
     }
     break;
   }
 #endif
   default:
     return false;
   }
   return true;
 }

◆ OPENDDS_VECTOR()

typedef OpenDDS::XTypes::DynamicDataImpl::OPENDDS_VECTOR ( CORBA::ULong )

private

◆ read_basic_in_complex_map()

template<typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_in_complex_map	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2738 of file DynamicDataImpl.cpp.

References container_, and read_basic_value().

Referenced by read_basic_member().

 {
   DataContainer::const_complex_iterator complex_it = container_.complex_map_.find(id);
   if (complex_it != container_.complex_map_.end()) {
     DynamicDataImpl* nested_dd = dynamic_cast<DynamicDataImpl*>(complex_it->second.in());
     return nested_dd && nested_dd->read_basic_value(value);
   }
   return false;
 }

◆ read_basic_in_single_map() [1/3]

template<typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_in_single_map	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Read a basic member from a containing type.

Definition at line 2703 of file DynamicDataImpl.cpp.

References container_.

Referenced by get_value_from_union(), and read_basic_member().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     value = single_it->second.get<ValueType>();
     return true;
   }
   return false;
 }

◆ read_basic_in_single_map() [2/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_in_single_map	(	char *&	value,
		DDS::MemberId	id
	)

Definition at line 2714 of file DynamicDataImpl.cpp.

References container_, and CORBA::string_free().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     CORBA::string_free(value);
     value = single_it->second.get_string();
     return true;
   }
   return false;
 }

◆ read_basic_in_single_map() [3/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_in_single_map	(	CORBA::WChar *&	value,
		DDS::MemberId	id
	)

Definition at line 2726 of file DynamicDataImpl.cpp.

References container_, and CORBA::wstring_free().

 {
   DataContainer::const_single_iterator single_it = container_.single_map_.find(id);
   if (single_it != container_.single_map_.end()) {
     CORBA::wstring_free(value);
     value = single_it->second.get_wstring();
     return true;
   }
   return false;
 }

◆ read_basic_member() [1/3]

template<typename ValueType >

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_member	(	ValueType &	value,
		DDS::MemberId	id
	)

private

Definition at line 2749 of file DynamicDataImpl.cpp.

References read_basic_in_complex_map(), and read_basic_in_single_map().

Referenced by get_char_common(), get_value_from_collection(), get_value_from_struct(), and get_value_from_union().

 {
   return read_basic_in_single_map(value, id) || read_basic_in_complex_map(value, id);
 }

◆ read_basic_member() [2/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_member	(	char *&	value,
		DDS::MemberId	id
	)

Definition at line 2755 of file DynamicDataImpl.cpp.

References read_basic_in_complex_map(), and read_basic_in_single_map().

 {
   return read_basic_in_single_map(value, id) || read_basic_in_complex_map(value, id);
 }

◆ read_basic_member() [3/3]

template<>

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_member	(	CORBA::WChar *&	value,
		DDS::MemberId	id
	)

Definition at line 2761 of file DynamicDataImpl.cpp.

References read_basic_in_complex_map(), and read_basic_in_single_map().

 {
   return read_basic_in_single_map(value, id) || read_basic_in_complex_map(value, id);
 }

◆ read_basic_value() [1/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_int8 & value )

private

Group of functions to read a basic value represented by this DynamicData instance.

Definition at line 2577 of file DynamicDataImpl.cpp.

References get_int8_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, and ACE_OutputCDR::from_int8::val_.

Referenced by OpenDDS::XTypes::DynamicDataImpl::get_boolean_from_bitmask< CORBA::UInt8 >(), get_boolean_from_bitmask(), get_simple_value_string(), read_basic_in_complex_map(), and read_basic_value().

 {
   return DDS::RETCODE_OK == get_int8_value(value.val_, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [2/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_uint8 & value )

private

Definition at line 2582 of file DynamicDataImpl.cpp.

References get_uint8_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, and ACE_OutputCDR::from_uint8::val_.

 {
   return DDS::RETCODE_OK == get_uint8_value(value.val_, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [3/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::Short & value )

private

Definition at line 2587 of file DynamicDataImpl.cpp.

References get_int16_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_int16_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [4/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::UShort & value )

private

Definition at line 2592 of file DynamicDataImpl.cpp.

References get_uint16_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_uint16_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [5/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::Long & value )

private

Definition at line 2597 of file DynamicDataImpl.cpp.

References get_int32_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_int32_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [6/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::ULong & value )

private

Definition at line 2602 of file DynamicDataImpl.cpp.

References get_uint32_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_uint32_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [7/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::LongLong & value )

private

Definition at line 2607 of file DynamicDataImpl.cpp.

References get_int64_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_int64_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [8/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::ULongLong & value )

private

Definition at line 2612 of file DynamicDataImpl.cpp.

References get_uint64_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_uint64_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [9/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::Float & value )

private

Definition at line 2617 of file DynamicDataImpl.cpp.

References get_float32_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_float32_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [10/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::Double & value )

private

Definition at line 2622 of file DynamicDataImpl.cpp.

References get_float64_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_float64_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [11/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( CORBA::LongDouble & value )

private

Definition at line 2627 of file DynamicDataImpl.cpp.

References get_float128_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, and DDS::RETCODE_OK.

 {
   return DDS::RETCODE_OK == get_float128_value(value, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [12/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_char & value )

private

Definition at line 2632 of file DynamicDataImpl.cpp.

References get_char16_value(), get_char8_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, read_basic_value(), DDS::RETCODE_OK, ACE_OutputCDR::from_wchar::val_, and ACE_OutputCDR::from_char::val_.

 {
   return DDS::RETCODE_OK == get_char8_value(value.val_, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [13/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_wchar & value )

private

◆ read_basic_value() [14/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_octet & value )

private

Definition at line 2644 of file DynamicDataImpl.cpp.

References get_byte_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, and ACE_OutputCDR::from_octet::val_.

 {
   return DDS::RETCODE_OK == get_byte_value(value.val_, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [15/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( ACE_OutputCDR::from_boolean & value )

private

Definition at line 2649 of file DynamicDataImpl.cpp.

References get_boolean_value(), OpenDDS::XTypes::MEMBER_ID_INVALID, DDS::RETCODE_OK, and ACE_OutputCDR::from_boolean::val_.

 {
   return DDS::RETCODE_OK == get_boolean_value(value.val_, MEMBER_ID_INVALID);
 }

◆ read_basic_value() [16/16]

bool OpenDDS::XTypes::DynamicDataImpl::read_basic_value ( char *& value ) const

private

Definition at line 2654 of file DynamicDataImpl.cpp.

References TAO::String_var< charT >::_retn(), container_, OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_largest_index_basic(), TAO::String_var< charT >::inout(), ACE_OS::memset(), read_basic_value(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::reconstruct_string_value(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::reconstruct_wstring_value(), CORBA::string_alloc(), CORBA::string_dup(), CORBA::string_free(), CORBA::wstring_alloc(), CORBA::wstring_dup(), and CORBA::wstring_free().

 {
   const bool is_empty = container_.single_map_.empty() && container_.complex_map_.empty();
   if (!is_empty) {
     CORBA::ULong largest_index;
     if (!container_.get_largest_index_basic(largest_index)) {
       return false;
     }
     const CORBA::ULong length = largest_index + 2;
     CORBA::String_var str_var = CORBA::string_alloc(length);
     ACE_OS::memset(str_var.inout(), 0, length);
     if (!container_.reconstruct_string_value(str_var.inout())) {
       return false;
     }
     CORBA::string_free(value);
     value = str_var._retn();
   } else {
     CORBA::string_free(value);
     value = CORBA::string_dup("");
   }
   return true;
 }

◆ read_discriminator() [1/2]

bool OpenDDS::XTypes::DynamicDataImpl::read_discriminator ( CORBA::Long & disc_val ) const

private

Definition at line 1296 of file DynamicDataImpl.cpp.

References container_, is_valid_discriminator_type(), OpenDDS::XTypes::MEMBER_ID_INVALID, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by set_complex_to_union().

 {
   if (!is_valid_discriminator_type(type_->get_kind())) {
     return false;
   }
   DataContainer::const_single_iterator it = container_.single_map_.find(MEMBER_ID_INVALID);
   if (it == container_.single_map_.end()) {
     return false;
   }
   return read_discriminator(disc_val, type_, it);
 }

◆ read_discriminator() [2/2]

bool OpenDDS::XTypes::DynamicDataImpl::read_discriminator	(	CORBA::Long &	disc_val,
		const DDS::DynamicType_var &	disc_type,
		DataContainer::const_single_iterator	it
	)		const

private

Definition at line 1209 of file DynamicDataImpl.cpp.

 {
   switch (disc_type->get_kind()) {
   case TK_BOOLEAN: {
     const ACE_OutputCDR::from_boolean& value = it->second.get<ACE_OutputCDR::from_boolean>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
   case TK_BYTE: {
     const ACE_OutputCDR::from_octet& value = it->second.get<ACE_OutputCDR::from_octet>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
   case TK_CHAR8: {
     const ACE_OutputCDR::from_char& value = it->second.get<ACE_OutputCDR::from_char>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16: {
     const ACE_OutputCDR::from_wchar& value = it->second.get<ACE_OutputCDR::from_wchar>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
 #endif
   case TK_INT8: {
     const ACE_OutputCDR::from_int8& value = it->second.get<ACE_OutputCDR::from_int8>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
   case TK_UINT8: {
     const ACE_OutputCDR::from_uint8& value = it->second.get<ACE_OutputCDR::from_uint8>();
     disc_val = static_cast<CORBA::Long>(value.val_);
     return true;
   }
   case TK_INT16: {
     CORBA::Short value = it->second.get<CORBA::Short>();
     disc_val = static_cast<CORBA::Long>(value);
     return true;
   }
   case TK_UINT16: {
     CORBA::UShort value = it->second.get<CORBA::UShort>();
     disc_val = static_cast<CORBA::Long>(value);
     return true;
   }
   case TK_INT32: {
     disc_val = it->second.get<CORBA::Long>();
     return true;
   }
   case TK_UINT32: {
     CORBA::ULong value = it->second.get<CORBA::ULong>();
     disc_val = static_cast<CORBA::Long>(value);
     return true;
   }
   case TK_INT64: {
     CORBA::LongLong value = it->second.get<CORBA::LongLong>();
     disc_val = static_cast<CORBA::Long>(value);
     return true;
   }
   case TK_UINT64: {
     CORBA::ULongLong value = it->second.get<CORBA::ULongLong>();
     disc_val = static_cast<CORBA::Long>(value);
     return true;
   }
   case TK_ENUM: {
     DDS::TypeDescriptor_var td;
     if (disc_type->get_descriptor(td) != DDS::RETCODE_OK) {
       return false;
     }
     const CORBA::ULong bitbound = td->bound()[0];
     if (bitbound >= 1 && bitbound <= 8) {
       const ACE_OutputCDR::from_int8& value = it->second.get<ACE_OutputCDR::from_int8>();
       disc_val = static_cast<CORBA::Long>(value.val_);
     } else if (bitbound >= 9 && bitbound <= 16) {
       CORBA::Short value = it->second.get<CORBA::Short>();
       disc_val = static_cast<CORBA::Long>(value);
     } else {
       disc_val = it->second.get<CORBA::Long>();
     }
     return true;
   }
   }
   return false;
 }

◆ return_loaned_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::return_loaned_value ( DDS::DynamicData_ptr value )

Definition at line 647 of file DynamicDataImpl.cpp.

References ACE_ERROR, LM_ERROR, and DDS::RETCODE_UNSUPPORTED.

 {
   ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: DynamicDataImpl::return_loaned_value: Not implemented\n"));
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ serialize_i()

bool OpenDDS::XTypes::DynamicDataImpl::serialize_i	(	DCPS::Serializer &	ser,
		DCPS::Sample::Extent	ext
	)		const

private

Definition at line 8699 of file DynamicDataImpl.cpp.

Referenced by OpenDDS::DCPS::operator<<(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_aggregated_member_xcdr2(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_aggregated_member_xcdr2_default(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_member_i().

 {
   const TypeKind tk = type_->get_kind();
   switch (tk) {
   case TK_INT32:
     return container_.serialize_primitive_value(ser, CORBA::Long());
   case TK_UINT32:
     return container_.serialize_primitive_value(ser, CORBA::ULong());
   case TK_INT8:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_int8(CORBA::Int8()));
   case TK_UINT8:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_uint8(CORBA::UInt8()));
   case TK_INT16:
     return container_.serialize_primitive_value(ser, CORBA::Short());
   case TK_UINT16:
     return container_.serialize_primitive_value(ser, CORBA::UShort());
   case TK_INT64:
     return container_.serialize_primitive_value(ser, CORBA::LongLong());
   case TK_UINT64:
     return container_.serialize_primitive_value(ser, CORBA::ULongLong());
   case TK_FLOAT32:
     return container_.serialize_primitive_value(ser, CORBA::Float());
   case TK_FLOAT64:
     return container_.serialize_primitive_value(ser, CORBA::Double());
   case TK_FLOAT128:
     return container_.serialize_primitive_value(ser, CORBA::LongDouble());
   case TK_CHAR8:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_char(CORBA::Char()));
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_wchar(CORBA::WChar()));
 #endif
   case TK_BYTE:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_octet(CORBA::Octet()));
   case TK_BOOLEAN:
     return container_.serialize_primitive_value(ser, ACE_OutputCDR::from_boolean(CORBA::Boolean()));
   case TK_ENUM:
     return container_.serialize_enum_value(ser);
   case TK_BITMASK:
     return container_.serialize_bitmask_value(ser);
   case TK_STRING8:
     return container_.serialize_string_value(ser);
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
     return container_.serialize_wstring_value(ser);
 #endif
   case TK_STRUCTURE:
     return container_.serialize_structure(ser, ext);
   case TK_UNION:
     return container_.serialize_union(ser, ext);
   case TK_SEQUENCE:
     return container_.serialize_sequence(ser, ext);
   case TK_ARRAY:
     return container_.serialize_array(ser, ext);
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::serialize_i: Serialization of map types is not supported\n"));
     }
   }
   return false;
 }

◆ serialized_size_i()

bool OpenDDS::XTypes::DynamicDataImpl::serialized_size_i	(	const DCPS::Encoding &	encoding,
		size_t &	size,
		DCPS::Sample::Extent	ext
	)		const

private

Definition at line 8631 of file DynamicDataImpl.cpp.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_aggregated_member_xcdr2(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_complex_aggregated_member_xcdr2_default(), OpenDDS::DCPS::serialized_size(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_complex_aggregated_member_xcdr2(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_complex_member_i().

 {
   const TypeKind tk = type_->get_kind();
   switch (tk) {
   case TK_INT32:
     return primitive_serialized_size(encoding, size, CORBA::Long());
   case TK_UINT32:
     return primitive_serialized_size(encoding, size, CORBA::ULong());
   case TK_INT8:
     primitive_serialized_size_int8(encoding, size);
     return true;
   case TK_UINT8:
     primitive_serialized_size_uint8(encoding, size);
     return true;
   case TK_INT16:
     return primitive_serialized_size(encoding, size, CORBA::Short());
   case TK_UINT16:
     return primitive_serialized_size(encoding, size, CORBA::UShort());
   case TK_INT64:
     return primitive_serialized_size(encoding, size, CORBA::LongLong());
   case TK_UINT64:
     return primitive_serialized_size(encoding, size, CORBA::ULongLong());
   case TK_FLOAT32:
     return primitive_serialized_size(encoding, size, CORBA::Float());
   case TK_FLOAT64:
     return primitive_serialized_size(encoding, size, CORBA::Double());
   case TK_FLOAT128:
     return primitive_serialized_size(encoding, size, CORBA::LongDouble());
   case TK_CHAR8:
     primitive_serialized_size_char(encoding, size);
     return true;
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
     primitive_serialized_size_wchar(encoding, size);
     return true;
 #endif
   case TK_BYTE:
     primitive_serialized_size_octet(encoding, size);
     return true;
   case TK_BOOLEAN:
     primitive_serialized_size_boolean(encoding, size);
     return true;
   case TK_ENUM:
     return container_.serialized_size_enum(encoding, size, type_);
   case TK_BITMASK:
     return container_.serialized_size_bitmask(encoding, size, type_);
   case TK_STRING8:
     return container_.serialized_size_string(encoding, size);
 #ifdef DDS_HAS_WCHAR
   case TK_STRING16:
     return container_.serialized_size_wstring(encoding, size);
 #endif
   case TK_STRUCTURE:
     return container_.serialized_size_structure(encoding, size, ext);
   case TK_UNION:
     return container_.serialized_size_union(encoding, size, ext);
   case TK_SEQUENCE:
     return container_.serialized_size_sequence(encoding, size, ext);
   case TK_ARRAY:
     return container_.serialized_size_array(encoding, size, ext);
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::serialized_size_i: Serialization of map types is not supported\n"));
     }
   }
   return false;
 }

◆ set_boolean_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_boolean_value	(	DDS::MemberId	id,
		CORBA::Boolean	value
	)

Definition at line 1868 of file DynamicDataImpl.cpp.

References ACE_ERROR, check_index_from_id(), insert_single(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_BITMASK, OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, and OpenDDS::XTypes::typekind_to_string().

Referenced by clear_value().

 {
   const TypeKind tk = type_->get_kind();
   bool good = true;
 
   switch (tk) {
   case TK_BOOLEAN:
     good = id == MEMBER_ID_INVALID && insert_single(id, ACE_OutputCDR::from_boolean(value));
     break;
   case TK_BITMASK: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       good = false;
       break;
     }
     const CORBA::ULong bit_bound = descriptor->bound()[0];
     if (!check_index_from_id(tk, id, bit_bound)) {
       good = false;
     } else {
       good = insert_single(id, ACE_OutputCDR::from_boolean(value));
     }
     break;
   }
   case TK_STRUCTURE:
     good = set_value_to_struct<TK_BOOLEAN>(id, ACE_OutputCDR::from_boolean(value));
     break;
   case TK_UNION:
     good = set_value_to_union<TK_BOOLEAN>(id, ACE_OutputCDR::from_boolean(value));
     break;
   case TK_SEQUENCE:
   case TK_ARRAY:
   case TK_MAP:
     good = set_value_to_collection<TK_BOOLEAN>(id, ACE_OutputCDR::from_boolean(value), tk);
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_boolean_value:"
                " Failed to write boolean to DynamicData object of type %C\n",
                typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ set_boolean_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_boolean_values	(	DDS::MemberId	id,
		const DDS::BooleanSeq &	value
	)

Definition at line 2558 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_BOOLEAN>(id, value);
 }

◆ set_byte_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_byte_value	(	DDS::MemberId	id,
		CORBA::Octet	value
	)

Definition at line 1863 of file DynamicDataImpl.cpp.

 {
   return set_single_value<TK_BYTE>(id, ACE_OutputCDR::from_octet(value));
 }

◆ set_byte_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_byte_values	(	DDS::MemberId	id,
		const DDS::ByteSeq &	value
	)

Definition at line 2553 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_BYTE>(id, value);
 }

◆ set_char16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_char16_value	(	DDS::MemberId	id,
		CORBA::WChar	value
	)

Definition at line 1854 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
 #ifdef DDS_HAS_WCHAR
   return set_char_common<TK_CHAR16, TK_STRING16>(id, ACE_OutputCDR::from_wchar(value));
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ set_char16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_char16_values	(	DDS::MemberId	id,
		const DDS::WcharSeq &	value
	)

Definition at line 2544 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED, and value.

 {
 #ifdef DDS_HAS_WCHAR
   return set_sequence_values<TK_CHAR16>(id, value);
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ set_char8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_char8_value	(	DDS::MemberId	id,
		CORBA::Char	value
	)

Definition at line 1849 of file DynamicDataImpl.cpp.

 {
   return set_char_common<TK_CHAR8, TK_STRING8>(id, ACE_OutputCDR::from_char(value));
 }

◆ set_char8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_char8_values	(	DDS::MemberId	id,
		const DDS::CharSeq &	value
	)

Definition at line 2539 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_CHAR8>(id, value);
 }

◆ set_char_common()

template<TypeKind CharKind, TypeKind StringKind, typename FromCharT >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_char_common	(	DDS::MemberId	id,
		const FromCharT &	value
	)

private

Definition at line 1803 of file DynamicDataImpl.cpp.

References ACE_ERROR, check_index_from_id(), insert_single(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and value.

 {
   const TypeKind tk = type_->get_kind();
   bool good = true;
 
   switch (tk) {
   case CharKind:
     good = id == MEMBER_ID_INVALID && insert_single(id, value);
     break;
   case StringKind: {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       good = false;
       break;
     }
     const CORBA::ULong bound = descriptor->bound()[0];
     if (!check_index_from_id(tk, id, bound)) {
       good = false;
     } else {
       good = insert_single(id, value);
     }
     break;
   }
   case TK_STRUCTURE:
     good = set_value_to_struct<CharKind>(id, value);
     break;
   case TK_UNION:
     good = set_value_to_union<CharKind>(id, value);
     break;
   case TK_SEQUENCE:
   case TK_ARRAY:
   case TK_MAP:
     good = set_value_to_collection<CharKind>(id, value, tk);
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_char_common:"
                " Failed to write DynamicData object of type %C\n", typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ set_complex_to_collection()

bool OpenDDS::XTypes::DynamicDataImpl::set_complex_to_collection	(	DDS::MemberId	id,
		DDS::DynamicData_var	value,
		TypeKind	tk
	)

private

Definition at line 2220 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::get_base_type(), insert_complex(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataBase::type_, and validate_member_id_collection().

Referenced by set_complex_value().

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var elem_type = get_base_type(descriptor->element_type());
   const DDS::DynamicType_var value_type = value->type();
   if (!elem_type->equals(value_type)) {
     return false;
   }
 
   return validate_member_id_collection(descriptor, id, collection_tk) && insert_complex(id, value);
 }

◆ set_complex_to_struct()

bool OpenDDS::XTypes::DynamicDataImpl::set_complex_to_struct	(	DDS::MemberId	id,
		DDS::DynamicData_var	value
	)

private

Definition at line 2108 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::get_base_type(), insert_complex(), DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by set_complex_value().

 {
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, id) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (member->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var member_type = get_base_type(md->type());
   const DDS::DynamicType_var value_type = value->type();
   if (!member_type || !value_type || !member_type->equals(value_type)) {
     return false;
   }
   return insert_complex(id, value);
 }

◆ set_complex_to_union()

bool OpenDDS::XTypes::DynamicDataImpl::set_complex_to_union	(	DDS::MemberId	id,
		DDS::DynamicData_var	value,
		const DDS::TypeDescriptor_var &	descriptor
	)

private

Definition at line 2127 of file DynamicDataImpl.cpp.

References ACE_ERROR, clear_container(), OpenDDS::XTypes::DISCRIMINATOR_ID, OpenDDS::XTypes::DynamicDataBase::discriminator_selects_no_member(), equals(), find_selected_member(), OpenDDS::XTypes::get_base_type(), insert_complex(), insert_valid_discriminator(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, read_discriminator(), DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataBase::type_, and validate_discriminator().

Referenced by set_complex_value().

 {
   if (id == DISCRIMINATOR_ID) {
     DDS::DynamicType_var disc_type = get_base_type(descriptor->discriminator_type());
     const DDS::DynamicType_var value_type = value->type();
     if (!disc_type->equals(value_type)) {
       return false;
     }
 
     CORBA::Long disc_val;
     const DynamicDataImpl* dd_impl = dynamic_cast<const DynamicDataImpl*>(value.in());
     if (!dd_impl || !dd_impl->read_discriminator(disc_val)) {
       return false;
     }
 
     const DDS::MemberId selected_id = find_selected_member();
     if (selected_id != MEMBER_ID_INVALID) {
       DDS::DynamicTypeMember_var selected_member;
       if (type_->get_member(selected_member, selected_id) != DDS::RETCODE_OK) {
         return false;
       }
       DDS::MemberDescriptor_var selected_md;
       if (selected_member->get_descriptor(selected_md) != DDS::RETCODE_OK) {
         return false;
       }
       if (!validate_discriminator(disc_val, selected_md)) {
         if (DCPS::log_level >= DCPS::LogLevel::Notice) {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_complex_to_union:"
                      " Discriminator value %d does not select the activated member (ID %u)\n",
                      disc_val, selected_id));
         }
         return false;
       }
       return insert_complex(id, value);
     } else {
       if (discriminator_selects_no_member(type_, disc_val)) {
         return insert_complex(id, value);
       }
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_complex_to_union:"
                    " Can't directly set a discriminator that selects a member."
                    " Activate the member first!\n"));
       }
       return false;
     }
   }
 
   // Activate a member
   clear_container();
 
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, id) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (member->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
   const DDS::DynamicType_var value_type = value->type();
   if (get_base_type(md->type())->equals(value_type)) {
     return false;
   }
 
   return insert_valid_discriminator(md) && insert_complex(id, value);
 }

◆ set_complex_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_complex_value	(	DDS::MemberId	id,
		DDS::DynamicData_ptr	value
	)

Definition at line 2237 of file DynamicDataImpl.cpp.

References ACE_ERROR, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, set_complex_to_collection(), set_complex_to_struct(), set_complex_to_union(), OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return DDS::RETCODE_ERROR;
   }
 
   DDS::DynamicData_var value_var = DDS::DynamicData::_duplicate(value);
   const TypeKind tk = type_->get_kind();
   bool good = false;
 
   switch (tk) {
   case TK_STRUCTURE:
     good = set_complex_to_struct(id, value_var);
     break;
   case TK_UNION:
     good = set_complex_to_union(id, value_var, descriptor);
     break;
   case TK_SEQUENCE:
   case TK_ARRAY:
   case TK_MAP:
     good = set_complex_to_collection(id, value_var, tk);
     break;
   default:
     good = false;
     break;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_complex_value:"
                " Failed to write complex value for member with ID %d\n", id));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ set_descriptor()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_descriptor	(	MemberId	id,
		DDS::MemberDescriptor *	value
	)

Definition at line 46 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED.

 {
   return DDS::RETCODE_UNSUPPORTED;
 }

◆ set_float128_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float128_value	(	DDS::MemberId	id,
		CORBA::LongDouble	value
	)

Definition at line 1797 of file DynamicDataImpl.cpp.

References value.

 {
   return set_single_value<TK_FLOAT128>(id, value);
 }

◆ set_float128_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float128_values	(	DDS::MemberId	id,
		const DDS::Float128Seq &	value
	)

Definition at line 2534 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_FLOAT128>(id, value);
 }

◆ set_float32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float32_value	(	DDS::MemberId	id,
		CORBA::Float	value
	)

Definition at line 1787 of file DynamicDataImpl.cpp.

References value.

 {
   return set_single_value<TK_FLOAT32>(id, value);
 }

◆ set_float32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float32_values	(	DDS::MemberId	id,
		const DDS::Float32Seq &	value
	)

Definition at line 2524 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_FLOAT32>(id, value);
 }

◆ set_float64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float64_value	(	DDS::MemberId	id,
		CORBA::Double	value
	)

Definition at line 1792 of file DynamicDataImpl.cpp.

References value.

 {
   return set_single_value<TK_FLOAT64>(id, value);
 }

◆ set_float64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_float64_values	(	DDS::MemberId	id,
		const DDS::Float64Seq &	value
	)

Definition at line 2529 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_FLOAT64>(id, value);
 }

◆ set_int16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int16_value	(	DDS::MemberId	id,
		CORBA::Short	value
	)

Definition at line 1767 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM, and value.

 {
   return set_single_value<TK_INT16>(id, value, TK_ENUM, 9, 16);
 }

◆ set_int16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int16_values	(	DDS::MemberId	id,
		const DDS::Int16Seq &	value
	)

Definition at line 2504 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM, and value.

 {
   return set_sequence_values<TK_INT16>(id, value, TK_ENUM, 9, 16);
 }

◆ set_int32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int32_value	(	DDS::MemberId	id,
		CORBA::Long	value
	)

Definition at line 1747 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM, and value.

 {
   return set_single_value<TK_INT32>(id, value, TK_ENUM, 17, 32);
 }

◆ set_int32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int32_values	(	DDS::MemberId	id,
		const DDS::Int32Seq &	value
	)

Definition at line 2484 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM, and value.

 {
   return set_sequence_values<TK_INT32>(id, value, TK_ENUM, 17, 32);
 }

◆ set_int64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int64_value	(	DDS::MemberId	id,
		CORBA::LongLong	value
	)

Definition at line 1777 of file DynamicDataImpl.cpp.

References value.

 {
   return set_single_value<TK_INT64>(id, value);
 }

◆ set_int64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int64_values	(	DDS::MemberId	id,
		const DDS::Int64Seq &	value
	)

Definition at line 2514 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_INT64>(id, value);
 }

◆ set_int8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int8_value	(	DDS::MemberId	id,
		CORBA::Int8	value
	)

Definition at line 1757 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM.

 {
   return set_single_value<TK_INT8>(id, ACE_OutputCDR::from_int8(value), TK_ENUM, 1, 8);
 }

◆ set_int8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_int8_values	(	DDS::MemberId	id,
		const DDS::Int8Seq &	value
	)

Definition at line 2494 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_ENUM, and value.

 {
   return set_sequence_values<TK_INT8>(id, value, TK_ENUM, 1, 8);
 }

◆ set_sequence_values()

template<TypeKind ElementTypeKind, typename SequenceType >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_sequence_values	(	DDS::MemberId	id,
		const SequenceType &	value,
		TypeKind	enum_or_bitmask = `TK_NONE`,
		LBound	lower = `0`,
		LBound	upper = `0`
	)

private

Definition at line 2438 of file DynamicDataImpl.cpp.

References ACE_ERROR, OpenDDS::XTypes::DynamicDataBase::is_type_supported(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and value.

 {
   if (!is_type_supported(ElementTypeKind, "set_sequence_values")) {
     return DDS::RETCODE_ERROR;
   }
 
   const TypeKind tk = type_->get_kind();
   bool good = true;
 
   switch (tk) {
   case TK_STRUCTURE:
     good = set_values_to_struct<ElementTypeKind>(id, value, enum_or_bitmask, lower, upper);
     break;
   case TK_UNION:
     good = set_values_to_union<ElementTypeKind>(id, value, enum_or_bitmask, lower, upper);
     break;
   case TK_SEQUENCE:
     good = set_values_to_sequence<ElementTypeKind>(id, value, enum_or_bitmask, lower, upper);
     break;
   case TK_ARRAY:
     good = set_values_to_array<ElementTypeKind>(id, value, enum_or_bitmask, lower, upper);
     break;
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_sequence_values:"
                  " Map is currently not supported\n"));
     }
     return DDS::RETCODE_ERROR;
   default:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_sequence_values:"
                  " Write to unsupported type (%C)\n", typekind_to_string(tk)));
     }
     return DDS::RETCODE_ERROR;
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_sequence_values:"
                " Failed to write sequence of %C to member with ID %d\n",
                typekind_to_string(ElementTypeKind), id));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ set_single_value()

template<TypeKind ValueTypeKind, typename ValueType >

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_single_value	(	DDS::MemberId	id,
		const ValueType &	value,
		TypeKind	enum_or_bitmask = `TK_NONE`,
		LBound	lower = `0`,
		LBound	upper = `0`
	)

private

Definition at line 1693 of file DynamicDataImpl.cpp.

References ACE_ERROR, insert_single(), OpenDDS::XTypes::DynamicDataBase::is_primitive(), OpenDDS::XTypes::DynamicDataBase::is_type_supported(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_ERROR, DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and value.

 {
   if (!is_type_supported(ValueTypeKind, "set_single_value")) {
     return DDS::RETCODE_ERROR;
   }
 
   const TypeKind tk = type_->get_kind();
   bool good = true;
 
   // TODO: Bitmask can be stored as a whole as a unsigned integer using MEMBER_ID_INVALID
   // (this is an extension to the XTypes spec). Elements of the bitmask can also be set
   // using the set_boolean_value interface. The two copies of the bitmask value must be
   // made consistent. For example, when a bit in the bitmask is updated, either update
   // the unsigned integer representation or invalidate it. Similarly, when the unsigned
   // integer value is updated, either update the stored elements or invalidate them all.
   if (tk == enum_or_bitmask) {
     DDS::TypeDescriptor_var descriptor;
     if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
       return DDS::RETCODE_ERROR;
     }
     const CORBA::ULong bit_bound = descriptor->bound()[0];
     good = id == MEMBER_ID_INVALID && bit_bound >= lower && bit_bound <= upper &&
       insert_single(id, value);
   } else {
     switch (tk) {
     case ValueTypeKind:
       good = is_primitive(tk) && id == MEMBER_ID_INVALID && insert_single(id, value);
       break;
     case TK_STRUCTURE:
       good = set_value_to_struct<ValueTypeKind>(id, value);
       break;
     case TK_UNION:
       good = set_value_to_union<ValueTypeKind>(id, value, enum_or_bitmask, lower, upper);
       break;
     case TK_SEQUENCE:
     case TK_ARRAY:
     case TK_MAP:
       good = set_value_to_collection<ValueTypeKind>(id, value, tk, enum_or_bitmask, lower, upper);
       break;
     default:
       good = false;
       break;
     }
   }
 
   if (!good && DCPS::log_level >= DCPS::LogLevel::Notice) {
     ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_single_value: "
                "Failed to write a value of %C to DynamicData object of type %C\n",
                typekind_to_string(ValueTypeKind), typekind_to_string(tk)));
   }
   return good ? DDS::RETCODE_OK : DDS::RETCODE_ERROR;
 }

◆ set_string_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_string_value	(	DDS::MemberId	id,
		const char *	value
	)

Definition at line 1915 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::get_enumerator_value(), OpenDDS::XTypes::get_member_type(), DDS::RETCODE_OK, OpenDDS::XTypes::set_enum_value(), OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::DynamicDataBase::type_, and value.

 {
   DDS::DynamicType_var mtype;
   DDS::ReturnCode_t rc = get_member_type(mtype, type_, id);
   if (rc != DDS::RETCODE_OK) {
     return rc;
   }
   if (mtype->get_kind() == TK_ENUM) {
     DDS::Int32 intValue;
     rc = get_enumerator_value(intValue, value, mtype);
     if (rc != DDS::RETCODE_OK) {
       return rc;
     }
     return set_enum_value(mtype, this, id, intValue);
   }
   return set_single_value<TK_STRING8>(id, value);
 }

◆ set_string_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_string_values	(	DDS::MemberId	id,
		const DDS::StringSeq &	value
	)

Definition at line 2563 of file DynamicDataImpl.cpp.

References value.

 {
   return set_sequence_values<TK_STRING8>(id, value);
 }

◆ set_uint16_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint16_value	(	DDS::MemberId	id,
		CORBA::UShort	value
	)

Definition at line 1772 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_single_value<TK_UINT16>(id, value, TK_BITMASK, 9, 16);
 }

◆ set_uint16_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint16_values	(	DDS::MemberId	id,
		const DDS::UInt16Seq &	value
	)

Definition at line 2509 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_sequence_values<TK_UINT16>(id, value, TK_BITMASK, 9, 16);
 }

◆ set_uint32_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint32_value	(	DDS::MemberId	id,
		CORBA::ULong	value
	)

Definition at line 1752 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_single_value<TK_UINT32>(id, value, TK_BITMASK, 17, 32);
 }

◆ set_uint32_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint32_values	(	DDS::MemberId	id,
		const DDS::UInt32Seq &	value
	)

Definition at line 2489 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_sequence_values<TK_UINT32>(id, value, TK_BITMASK, 17, 32);
 }

◆ set_uint64_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint64_value	(	DDS::MemberId	id,
		CORBA::ULongLong	value
	)

Definition at line 1782 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_single_value<TK_UINT64>(id, value, TK_BITMASK, 33, 64);
 }

◆ set_uint64_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint64_values	(	DDS::MemberId	id,
		const DDS::UInt64Seq &	value
	)

Definition at line 2519 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_sequence_values<TK_UINT64>(id, value, TK_BITMASK, 33, 64);
 }

◆ set_uint8_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint8_value	(	DDS::MemberId	id,
		CORBA::UInt8	value
	)

Definition at line 1762 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK.

 {
   return set_single_value<TK_UINT8>(id, ACE_OutputCDR::from_uint8(value), TK_BITMASK, 1, 8);
 }

◆ set_uint8_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_uint8_values	(	DDS::MemberId	id,
		const DDS::UInt8Seq &	value
	)

Definition at line 2499 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::TK_BITMASK, and value.

 {
   return set_sequence_values<TK_UINT8>(id, value, TK_BITMASK, 1, 8);
 }

◆ set_value_to_collection()

template<TypeKind ElementTypeKind, typename ElementType >

bool OpenDDS::XTypes::DynamicDataImpl::set_value_to_collection	(	DDS::MemberId	id,
		const ElementType &	value,
		TypeKind	coll_tk,
		TypeKind	enum_or_bitmask = `TK_NONE`,
		LBound	lower = `0`,
		LBound	upper = `0`
	)

private

Definition at line 1656 of file DynamicDataImpl.cpp.

References ACE_ERROR, OpenDDS::XTypes::get_base_type(), insert_single(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and validate_member_id_collection().

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
 
   const DDS::DynamicType_var elem_type = get_base_type(descriptor->element_type());
   const TypeKind elem_tk = elem_type->get_kind();
 
   if (elem_tk != ElementTypeKind && elem_tk != enum_or_bitmask) {
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_value_to_collection:"
                  " Could not write a value of type %C to %C with element type %C\n",
                  typekind_to_string(ElementTypeKind), typekind_to_string(collection_tk),
                  typekind_to_string(elem_tk)));
     }
     return false;
   }
 
   if (elem_tk == enum_or_bitmask) {
     DDS::TypeDescriptor_var elem_td;
     if (elem_type->get_descriptor(elem_td) != DDS::RETCODE_OK) {
       return false;
     }
     const CORBA::ULong bit_bound = elem_td->bound()[0];
     if (bit_bound < lower || bit_bound > upper) {
       return false;
     }
   }
 
   return validate_member_id_collection(descriptor, id, collection_tk) &&
     insert_single(id, value);
 }

◆ set_value_to_struct()

template<TypeKind MemberTypeKind, typename MemberType >

bool OpenDDS::XTypes::DynamicDataImpl::set_value_to_struct	(	DDS::MemberId	id,
		const MemberType &	value
	)

private

Definition at line 732 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataBase::check_member(), insert_single(), and DDS::RETCODE_OK.

 {
   DDS::MemberDescriptor_var md;
   DDS::DynamicType_var member_type;
   const DDS::ReturnCode_t rc = check_member(
     md, member_type, "DynamicDataImpl::set_value_to_struct", "set", id, MemberTypeKind);
   if (rc != DDS::RETCODE_OK) {
     return false;
   }
   return insert_single(id, value);
 }

◆ set_value_to_union()

template<TypeKind MemberTypeKind, typename MemberType >

bool OpenDDS::XTypes::DynamicDataImpl::set_value_to_union	(	DDS::MemberId	id,
		const MemberType &	value,
		TypeKind	enum_or_bitmask = `TK_NONE`,
		LBound	lower = `0`,
		LBound	upper = `0`
	)

private

Definition at line 1457 of file DynamicDataImpl.cpp.

References ACE_ERROR, cast_to_discriminator_value(), clear_container(), OpenDDS::XTypes::DISCRIMINATOR_ID, OpenDDS::XTypes::DynamicDataBase::discriminator_selects_no_member(), find_selected_member(), OpenDDS::XTypes::get_base_type(), insert_single(), insert_valid_discriminator(), is_valid_discriminator_type(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_OK, OpenDDS::XTypes::DynamicDataBase::type_, OpenDDS::XTypes::typekind_to_string(), and validate_discriminator().

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
 
   // This follows the IDL-to-C++ mapping for union.
   DDS::DynamicType_var member_type;
   if (id == DISCRIMINATOR_ID) {
     // Discriminator can only be of certain types (XTypes spec, 7.2.2.4.4.3)
     if (!is_valid_discriminator_type(MemberTypeKind)) {
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_value_to_union:"
                    " Type %C cannot be used for union discriminator\n",
                    typekind_to_string(MemberTypeKind)));
       }
       return false;
     }
 
     member_type = get_base_type(descriptor->discriminator_type());
 
     const TypeKind member_tk = member_type->get_kind();
     if (member_tk != MemberTypeKind && member_tk != enum_or_bitmask) {
       return false;
     }
 
     if (member_tk == enum_or_bitmask) {
       DDS::TypeDescriptor_var member_td;
       if (member_type->get_descriptor(member_td) != DDS::RETCODE_OK) {
         return false;
       }
       const CORBA::ULong bit_bound = member_td->bound()[0];
       if (bit_bound < lower || bit_bound > upper) {
         return false;
       }
     }
 
     CORBA::Long disc_value;
     if (!cast_to_discriminator_value(disc_value, value)) {
       return false;
     }
 
     const DDS::MemberId selected_id = find_selected_member();
     if (selected_id != MEMBER_ID_INVALID) {
       DDS::DynamicTypeMember_var selected_member;
       if (type_->get_member(selected_member, selected_id) != DDS::RETCODE_OK) {
         return false;
       }
       DDS::MemberDescriptor_var selected_md;
       if (selected_member->get_descriptor(selected_md) != DDS::RETCODE_OK) {
         return false;
       }
 
       if (!validate_discriminator(disc_value, selected_md)) {
         if (DCPS::log_level >= DCPS::LogLevel::Notice) {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_value_to_union:"
                      " Discriminator value %d does not select the activated member (ID %u)\n",
                      disc_value, selected_id));
         }
         return false;
       }
       return insert_single(id, value);
     } else {
       // In case the union has implicit default member and the input discriminator value
       // selects that implicit default member, store the discriminator value. The semantics
       // of this is similar to the _default() method of the IDL-to-C++ mapping for union.
       if (discriminator_selects_no_member(type_, disc_value)) {
         return insert_single(id, value);
       }
       if (DCPS::log_level >= DCPS::LogLevel::Notice) {
         ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_value_to_union:"
                    " Can't directly set a discriminator that selects a member."
                    " Activate the member first!\n"));
       }
       return false;
     }
   }
 
   // Activate a member
   clear_container();
 
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, id) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (member->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
   member_type = get_base_type(md->type());
 
   const TypeKind member_tk = member_type->get_kind();
   if (member_tk != MemberTypeKind && member_tk != enum_or_bitmask) {
     return false;
   }
 
   return insert_valid_discriminator(md) && insert_single(id, value);
 }

◆ set_values_to_array()

template<TypeKind ElementTypeKind, typename SequenceType >

bool OpenDDS::XTypes::DynamicDataImpl::set_values_to_array	(	DDS::MemberId	id,
		const SequenceType &	value,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)

private

Definition at line 2422 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataBase::bound_total(), insert_sequence(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::DynamicDataBase::type_, and validate_member_id_collection().

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
   const CORBA::ULong length = bound_total(descriptor);
   return
     check_seqmem_in_sequence_and_array<ElementTypeKind>(id, length, enum_or_bitmask, lower, upper) &&
     validate_member_id_collection(descriptor, id, TK_ARRAY) &&
     insert_sequence(id, value);
 }

◆ set_values_to_sequence()

template<TypeKind ElementTypeKind, typename SequenceType >

bool OpenDDS::XTypes::DynamicDataImpl::set_values_to_sequence	(	DDS::MemberId	id,
		const SequenceType &	value,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)

private

Definition at line 2406 of file DynamicDataImpl.cpp.

References insert_sequence(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_SEQUENCE, OpenDDS::XTypes::DynamicDataBase::type_, and validate_member_id_collection().

 {
   DDS::TypeDescriptor_var descriptor;
   if (type_->get_descriptor(descriptor) != DDS::RETCODE_OK) {
     return false;
   }
   const CORBA::ULong bound = descriptor->bound()[0];
   return
     check_seqmem_in_sequence_and_array<ElementTypeKind>(id, bound, enum_or_bitmask, lower, upper) &&
     validate_member_id_collection(descriptor, id, TK_SEQUENCE) &&
     insert_sequence(id, value);
 }

◆ set_values_to_struct()

template<TypeKind ElementTypeKind, typename SequenceType >

bool OpenDDS::XTypes::DynamicDataImpl::set_values_to_struct	(	DDS::MemberId	id,
		const SequenceType &	value,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)

private

Definition at line 2325 of file DynamicDataImpl.cpp.

References insert_sequence().

 {
   return check_seqmem_in_struct_and_union<ElementTypeKind>(id, enum_or_bitmask, lower, upper) &&
     insert_sequence(id, value);
 }

◆ set_values_to_union()

template<TypeKind ElementTypeKind, typename SequenceType >

bool OpenDDS::XTypes::DynamicDataImpl::set_values_to_union	(	DDS::MemberId	id,
		const SequenceType &	value,
		TypeKind	enum_or_bitmask,
		LBound	lower,
		LBound	upper
	)

private

Definition at line 2334 of file DynamicDataImpl.cpp.

References ACE_ERROR, clear_container(), OpenDDS::XTypes::DISCRIMINATOR_ID, insert_sequence(), insert_valid_discriminator(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, DDS::RETCODE_OK, and OpenDDS::XTypes::DynamicDataBase::type_.

 {
   if (id == DISCRIMINATOR_ID) {
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::set_values_to_union:"
                  " Union discriminator cannot be a sequence\n"));
     }
     return false;
   }
 
   // Check the member type against the input type parameters.
   if (!check_seqmem_in_struct_and_union<ElementTypeKind>(id, enum_or_bitmask, lower, upper)) {
     return false;
   }
 
   clear_container();
 
   DDS::DynamicTypeMember_var member;
   if (type_->get_member(member, id) != DDS::RETCODE_OK) {
     return false;
   }
   DDS::MemberDescriptor_var md;
   if (member->get_descriptor(md) != DDS::RETCODE_OK) {
     return false;
   }
   return insert_valid_discriminator(md) && insert_sequence(id, value);
 }

◆ set_wstring_value()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_wstring_value	(	DDS::MemberId	id,
		const CORBA::WChar *	value
	)

Definition at line 1933 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED, and value.

 {
 #ifdef DDS_HAS_WCHAR
   return set_single_value<TK_STRING16>(id, value);
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ set_wstring_values()

DDS::ReturnCode_t OpenDDS::XTypes::DynamicDataImpl::set_wstring_values	(	DDS::MemberId	id,
		const DDS::WstringSeq &	value
	)

Definition at line 2568 of file DynamicDataImpl.cpp.

References DDS::RETCODE_UNSUPPORTED, and value.

 {
 #ifdef DDS_HAS_WCHAR
   return set_sequence_values<TK_STRING16>(id, value);
 #else
   return DDS::RETCODE_UNSUPPORTED;
 #endif
 }

◆ type()

DDS::DynamicType_ptr OpenDDS::XTypes::DynamicDataImpl::type ( void )

Definition at line 41 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::DynamicDataBase::type_.

Referenced by move_sequence_to_complex(), and move_single_to_complex().

 {
   return DDS::DynamicType::_duplicate(type_);
 }

◆ validate_discriminator()

bool OpenDDS::XTypes::DynamicDataImpl::validate_discriminator	(	CORBA::Long	disc_val,
		const DDS::MemberDescriptor_var &	md
	)		const

private

Definition at line 1340 of file DynamicDataImpl.cpp.

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

Referenced by set_complex_to_union(), and set_value_to_union().

 {
   // If the selected member is not default, the discriminator value must equal one of its
   // labels. If the selected member is default, the discriminator value must not equal
   // any label of the non-default members.
   if (!md->is_default_label()) {
     const DDS::UnionCaseLabelSeq& labels = md->label();
     bool found = false;
     for (CORBA::ULong i = 0; !found && i < labels.length(); ++i) {
       if (disc_val == labels[i]) {
         found = true;
       }
     }
     if (!found) {
       return false;
     }
   } else if (!is_default_member_selected(disc_val, md->id())) {
     return false;
   }
   return true;
 }

◆ validate_member_id_collection()

bool OpenDDS::XTypes::DynamicDataImpl::validate_member_id_collection	(	const DDS::TypeDescriptor_var &	descriptor,
		DDS::MemberId	id,
		TypeKind	collection_tk
	)		const

private

Definition at line 2194 of file DynamicDataImpl.cpp.

References ACE_ERROR, check_index_from_id(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::TK_MAP, and OpenDDS::XTypes::TK_SEQUENCE.

Referenced by set_complex_to_collection(), set_value_to_collection(), set_values_to_array(), and set_values_to_sequence().

 {
   switch (tk) {
   case TK_SEQUENCE:
     {
       const CORBA::ULong bound = descriptor->bound()[0];
       return check_index_from_id(tk, id, bound);
     }
   case TK_ARRAY:
     {
       CORBA::ULong bound = 1;
       for (CORBA::ULong i = 0; i < descriptor->bound().length(); ++i) {
         bound *= descriptor->bound()[i];
       }
       return check_index_from_id(tk, id, bound);
     }
   case TK_MAP:
     if (DCPS::log_level >= DCPS::LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: DynamicDataImpl::validate_member_id_collection::"
                  " Map is currently not supported\n"));
     }
   }
   return false;
 }

◆ write_discriminator()

bool OpenDDS::XTypes::DynamicDataImpl::write_discriminator ( CORBA::Long value )

private

Definition at line 3752 of file DynamicDataImpl.cpp.

References OpenDDS::XTypes::enum_bound(), DDS::RETCODE_OK, OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::DynamicDataBase::type_, and write_discriminator_helper().

Referenced by get_complex_from_union().

 {
   TypeKind treat_as = type_->get_kind();
   if (treat_as == TK_ENUM) {
     if (enum_bound(type_, treat_as) != DDS::RETCODE_OK) {
       return false;
     }
   }
   return write_discriminator_helper(value, treat_as);
 }

◆ write_discriminator_helper()

bool OpenDDS::XTypes::DynamicDataImpl::write_discriminator_helper	(	CORBA::Long	value,
		TypeKind	treat_as
	)

private

Definition at line 3717 of file DynamicDataImpl.cpp.

References insert_single(), OpenDDS::XTypes::MEMBER_ID_INVALID, OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_BYTE, OpenDDS::XTypes::TK_CHAR16, OpenDDS::XTypes::TK_CHAR8, OpenDDS::XTypes::TK_INT16, OpenDDS::XTypes::TK_INT32, OpenDDS::XTypes::TK_INT64, OpenDDS::XTypes::TK_INT8, OpenDDS::XTypes::TK_UINT16, OpenDDS::XTypes::TK_UINT32, OpenDDS::XTypes::TK_UINT64, and OpenDDS::XTypes::TK_UINT8.

Referenced by write_discriminator().

 {
   switch (treat_as) {
   case TK_BOOLEAN:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_boolean(value));
   case TK_BYTE:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_octet(value));
   case TK_CHAR8:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_char(value));
 #ifdef DDS_HAS_WCHAR
   case TK_CHAR16:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_wchar(value));
 #endif
   case TK_INT8:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_int8(value));
   case TK_UINT8:
     return insert_single(MEMBER_ID_INVALID, ACE_OutputCDR::from_uint8(value));
   case TK_INT16:
     return insert_single(MEMBER_ID_INVALID, static_cast<CORBA::Short>(value));
   case TK_UINT16:
     return insert_single(MEMBER_ID_INVALID, static_cast<CORBA::UShort>(value));
   case TK_INT32:
     return insert_single(MEMBER_ID_INVALID, value);
   case TK_UINT32:
     return insert_single(MEMBER_ID_INVALID, static_cast<CORBA::ULong>(value));
   case TK_INT64:
     return insert_single(MEMBER_ID_INVALID, static_cast<CORBA::LongLong>(value));
   case TK_UINT64:
     return insert_single(MEMBER_ID_INVALID, static_cast<CORBA::ULongLong>(value));
   default:
     return false;
   }
 }

Friends And Related Function Documentation

◆ DCPS::operator<< [1/2]

OpenDDS_Dcps_Export bool DCPS::operator<<	(	DCPS::Serializer &	ser,
		const DynamicDataImpl &	data
	)

friend

◆ DCPS::operator<< [2/2]

OpenDDS_Dcps_Export bool DCPS::operator<<	(	DCPS::Serializer &	ser,
		const DCPS::KeyOnly< const DynamicDataImpl > &	data
	)

friend

◆ DCPS::serialized_size [1/2]

OpenDDS_Dcps_Export bool DCPS::serialized_size	(	const DCPS::Encoding &	encoding,
		size_t &	size,
		const DynamicDataImpl &	data
	)

friend

◆ DCPS::serialized_size [2/2]

OpenDDS_Dcps_Export bool DCPS::serialized_size	(	const DCPS::Encoding &	encoding,
		size_t &	size,
		const DCPS::KeyOnly< const DynamicDataImpl > &	data
	)

friend

Member Data Documentation

◆ container_

DataContainer OpenDDS::XTypes::DynamicDataImpl::container_

private

Definition at line 1014 of file DynamicDataImpl.h.

Referenced by clear_container(), clear_value(), clear_value_i(), erase_member(), find_selected_member(), get_boolean_value(), get_char_common(), get_complex_from_aggregated(), get_complex_from_collection(), get_complex_from_union(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::get_discriminator_value(), get_item_count(), get_member_id_at_index(), get_sequence_size(), get_simple_value_boolean(), get_simple_value_char(), get_simple_value_primitive(), get_simple_value_string(), get_value_from_bitmask(), get_value_from_collection(), get_value_from_enum(), get_value_from_self(), get_value_from_struct(), get_value_from_union(), insert_complex(), insert_sequence(), insert_single(), read_basic_in_complex_map(), read_basic_in_single_map(), read_basic_value(), read_discriminator(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::reconstruct_string_value(), serialize_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_string_value(), serialized_size_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::set_primitive_values().

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ FoundStatus

Constructor & Destructor Documentation

◆ DynamicDataImpl() [1/2]

◆ DynamicDataImpl() [2/2]

Member Function Documentation

◆ cast_to_discriminator_value() [1/12]

◆ cast_to_discriminator_value() [2/12]

◆ cast_to_discriminator_value() [3/12]

◆ cast_to_discriminator_value() [4/12]

◆ cast_to_discriminator_value() [5/12]

◆ cast_to_discriminator_value() [6/12]

◆ cast_to_discriminator_value() [7/12]

◆ cast_to_discriminator_value() [8/12]

◆ cast_to_discriminator_value() [9/12]

◆ cast_to_discriminator_value() [10/12]

◆ cast_to_discriminator_value() [11/12]

◆ cast_to_discriminator_value() [12/12]

◆ cast_to_enum_value() [1/4]

◆ cast_to_enum_value() [2/4]

◆ cast_to_enum_value() [3/4]

◆ cast_to_enum_value() [4/4]

◆ check_index_from_id()

◆ check_seqmem_in_sequence_and_array()

◆ check_seqmem_in_struct_and_union()

◆ clear_all_values()

◆ clear_container()

◆ clear_nonkey_values()

◆ clear_value()

◆ clear_value_i()

◆ clone()

◆ equals()

◆ erase_member()

◆ find_selected_member()

◆ get_boolean_from_bitmask()

◆ get_boolean_value()

◆ get_boolean_values()

◆ get_byte_value()

◆ get_byte_values()

◆ get_char16_value()

◆ get_char16_values()

◆ get_char8_value()

◆ get_char8_values()

◆ get_char_common()

◆ get_complex_from_aggregated()

◆ get_complex_from_collection()

◆ get_complex_from_struct()

◆ get_complex_from_union()

◆ get_complex_value()

◆ get_float128_value()

◆ get_float128_values()

◆ get_float32_value()

◆ get_float32_values()

◆ get_float64_value()

◆ get_float64_values()

◆ get_int16_value()

◆ get_int16_values()

◆ get_int32_value()

◆ get_int32_values()

◆ get_int64_value()

◆ get_int64_values()

◆ get_int8_value()

◆ get_int8_values()

◆ get_item_count()

◆ get_member_id_at_index()

◆ get_sequence_size()

◆ get_simple_value()

◆ get_simple_value_boolean()

◆ get_simple_value_char()

◆ get_simple_value_enum()

◆ get_simple_value_primitive()