#include <TypeLookupService.h>

Inheritance diagram for OpenDDS::XTypes::TypeLookupService:

Collaboration diagram for OpenDDS::XTypes::TypeLookupService:

[legend]

Public Member Functions
	TypeLookupService ()

	~TypeLookupService ()

const TypeObject &	get_type_object (const TypeIdentifier &type_id) const
	For TypeAssignability. More...

void	add (const TypeIdentifier &ti, const TypeObject &tobj)

void	get_type_objects (const TypeIdentifierSeq &type_ids, TypeIdentifierTypeObjectPairSeq &types) const
	For TypeLookup_getTypes. More...

void	add_type_objects_to_cache (const TypeIdentifierTypeObjectPairSeq &types)

typedef	OPENDDS_MAP (TypeIdentifier, DDS::DynamicType_var) DynamicTypeMap

typedef	OPENDDS_MAP (DCPS::GUID_t, DynamicTypeMap) GuidTypeMap

DDS::DynamicType_ptr	complete_to_dynamic (const CompleteTypeObject &cto, const DCPS::GUID_t &guid)

void	remove_guid_from_dynamic_map (const DCPS::GUID_t &guid)

bool	has_complete (const TypeIdentifier &ti) const

DDS::DynamicType_ptr	type_identifier_to_dynamic (const TypeIdentifier &ti, const DCPS::GUID_t &guid)

bool	get_type_dependencies (const TypeIdentifier &type_id, TypeIdentifierWithSizeSeq &dependencies) const
	For TypeLookup_getTypeDependencies. More...

void	get_type_dependencies (const TypeIdentifierSeq &type_ids, TypeIdentifierWithSizeSeq &dependencies) const

void	add_type_dependencies (const TypeIdentifier &type_id, const TypeIdentifierWithSizeSeq &dependencies)

void	add (TypeMap::const_iterator begin, TypeMap::const_iterator end)
	For adding local endpoint types. More...

bool	type_object_in_cache (const TypeIdentifier &ti) const

bool	extensibility (TypeFlag extensibility_mask, const TypeIdentifier &ti) const

void	cache_type_info (const DDS::BuiltinTopicKey_t &key, const TypeInformation &type_info)
	For caching and retrieving TypeInformation of remote endpoints. More...

const TypeInformation &	get_type_info (const DDS::BuiltinTopicKey_t &key) const


void	update_type_identifier_map (const TypeIdentifierPairSeq &tid_pairs)

bool	complete_to_minimal_type_object (const TypeObject &cto, TypeObject &mto) const

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

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Private Member Functions
const TypeObject &	get_type_object_i (const TypeIdentifier &type_id) const

void	get_type_dependencies_i (const TypeIdentifierSeq &type_ids, TypeIdentifierWithSizeSeq &dependencies) const

typedef	OPENDDS_MAP (TypeIdentifier, TypeIdentifierWithSizeSeq) TypeIdentifierWithSizeSeqMap
	For dependencies of local types. More...

typedef	OPENDDS_MAP (TypeIdentifier, TypeIdentifier) TypeIdentifierMap
	Mapping from complete to minimal TypeIdentifiers of dependencies of remote types. More...

bool	get_minimal_type_identifier (const TypeIdentifier &ct, TypeIdentifier &mt) const

bool	set_type_object_defaults (TypeObject &to)

bool	complete_to_minimal_struct (const CompleteStructType &ct, MinimalStructType &mt) const

bool	complete_to_minimal_union (const CompleteUnionType &ct, MinimalUnionType &mt) const

bool	complete_to_minimal_annotation (const CompleteAnnotationType &ct, MinimalAnnotationType &mt) const

bool	complete_to_minimal_alias (const CompleteAliasType &ct, MinimalAliasType &mt) const

bool	complete_to_minimal_sequence (const CompleteSequenceType &ct, MinimalSequenceType &mt) const

bool	complete_to_minimal_array (const CompleteArrayType &ct, MinimalArrayType &mt) const

bool	complete_to_minimal_map (const CompleteMapType &ct, MinimalMapType &mt) const

bool	complete_to_minimal_enumerated (const CompleteEnumeratedType &ct, MinimalEnumeratedType &mt) const

bool	complete_to_minimal_bitmask (const CompleteBitmaskType &ct, MinimalBitmaskType &mt) const

bool	complete_to_minimal_bitset (const CompleteBitsetType &ct, MinimalBitsetType &mt) const

DDS::MemberDescriptor *	complete_struct_member_to_member_descriptor (const CompleteStructMember &cm, const DCPS::GUID_t &guid)

DDS::MemberDescriptor *	complete_union_member_to_member_descriptor (const CompleteUnionMember &cm, const DCPS::GUID_t &guid)

DDS::MemberDescriptor *	complete_annotation_member_to_member_descriptor (const CompleteAnnotationParameter &cm, const DCPS::GUID_t &guid)

void	complete_to_dynamic_i (DynamicTypeImpl *dt, const CompleteTypeObject &cto, const DCPS::GUID_t &guid)

typedef	OPENDDS_MAP_CMP (DDS::BuiltinTopicKey_t, TypeInformation, DCPS::BuiltinTopicKey_tKeyLessThan) TypeInformationMap
	Map from BuiltinTopicKey_t of remote endpoint to its TypeInformation. More...

Private Attributes
TypeMap	type_map_
	Contains both minimal and complete type mapping. More...

TypeIdentifierWithSizeSeqMap	type_dependencies_map_

ACE_Thread_Mutex	mutex_

TypeObject	to_empty_

TypeIdentifierMap	complete_to_minimal_ti_map_

GuidTypeMap	gt_map_

TypeInformationMap	type_info_map_

TypeInformation	type_info_empty_

Additional Inherited Members
Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Detailed Description

Definition at line 29 of file TypeLookupService.h.

Constructor & Destructor Documentation

◆ TypeLookupService()

OpenDDS::XTypes::TypeLookupService::TypeLookupService ( )

Definition at line 37 of file TypeLookupService.cpp.

References OpenDDS::XTypes::TK_NONE.

 {
   to_empty_.minimal.kind = TK_NONE;
   to_empty_.complete.kind = TK_NONE;
 
   type_info_empty_.minimal.typeid_with_size.type_id = TypeIdentifier(TK_NONE);
   type_info_empty_.complete.typeid_with_size.type_id = TypeIdentifier(TK_NONE);
 }

◆ ~TypeLookupService()

OpenDDS::XTypes::TypeLookupService::~TypeLookupService ( )

Definition at line 46 of file TypeLookupService.cpp.

 {
 #ifndef OPENDDS_SAFETY_PROFILE
   for (GuidTypeMap::const_iterator pos = gt_map_.begin(), limit = gt_map_.end(); pos != limit; ++pos) {
     for (DynamicTypeMap::const_iterator pos2 = pos->second.begin(), limit2 = pos->second.end(); pos2 != limit2; ++pos2) {
       pos2->second->clear();
     }
   }
 #endif
 }

Member Function Documentation

◆ add() [1/2]

void OpenDDS::XTypes::TypeLookupService::add	(	const TypeIdentifier &	ti,
		const TypeObject &	tobj
	)

Definition at line 149 of file TypeLookupService.cpp.

References ACE_GUARD.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   TypeMap::const_iterator pos = type_map_.find(ti);
   if (pos == type_map_.end()) {
     type_map_.insert(std::make_pair(ti, tobj));
   }
 }

◆ add() [2/2]

void OpenDDS::XTypes::TypeLookupService::add	(	TypeMap::const_iterator	begin,
		TypeMap::const_iterator	end
	)

For adding local endpoint types.

Definition at line 143 of file TypeLookupService.cpp.

References ACE_GUARD.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   type_map_.insert(begin, end);
 }

◆ add_type_dependencies()

void OpenDDS::XTypes::TypeLookupService::add_type_dependencies	(	const TypeIdentifier &	type_id,
		const TypeIdentifierWithSizeSeq &	dependencies
	)

Definition at line 1102 of file TypeLookupService.cpp.

References ACE_GUARD.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   if (type_dependencies_map_.find(type_id) == type_dependencies_map_.end()) {
     type_dependencies_map_.insert(std::make_pair(type_id, dependencies));
   }
 }

◆ add_type_objects_to_cache()

void OpenDDS::XTypes::TypeLookupService::add_type_objects_to_cache ( const TypeIdentifierTypeObjectPairSeq & types )

Definition at line 129 of file TypeLookupService.cpp.

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

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   for (unsigned i = 0; i < types.length(); ++i) {
     const TypeMap::iterator pos = type_map_.find(types[i].type_identifier);
     if (pos == type_map_.end()) {
       TypeObject to = types[i].type_object;
       if (set_type_object_defaults(to)) {
         type_map_.insert(std::make_pair(types[i].type_identifier, to));
       }
     }
   }
 }

◆ cache_type_info()

void OpenDDS::XTypes::TypeLookupService::cache_type_info	(	const DDS::BuiltinTopicKey_t &	key,
		const TypeInformation &	type_info
	)

For caching and retrieving TypeInformation of remote endpoints.

Definition at line 166 of file TypeLookupService.cpp.

References ACE_GUARD.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   if (type_info_map_.find(key) == type_info_map_.end()) {
     type_info_map_.insert(std::make_pair(key, type_info));
   }
 }

◆ complete_annotation_member_to_member_descriptor()

DDS::MemberDescriptor * OpenDDS::XTypes::TypeLookupService::complete_annotation_member_to_member_descriptor	(	const CompleteAnnotationParameter &	cm,
		const DCPS::GUID_t &	guid
	)

private

Definition at line 650 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteAnnotationParameter::common, DDS::DISCARD, OpenDDS::XTypes::CommonAnnotationParameter::member_type_id, and OpenDDS::XTypes::CompleteAnnotationParameter::name.

 {
   DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
   md->name(cm.name.c_str());
   DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.member_type_id, guid);
   md->type(dt);
   md->try_construct_kind(DDS::DISCARD);
   md->is_key(false);
   md->is_optional(false);
   md->is_must_understand(false);
   md->is_shared(false);
   md->is_default_label(false);
   return md._retn();
 }

◆ complete_struct_member_to_member_descriptor()

DDS::MemberDescriptor * OpenDDS::XTypes::TypeLookupService::complete_struct_member_to_member_descriptor	(	const CompleteStructMember &	cm,
		const DCPS::GUID_t &	guid
	)

private

Definition at line 608 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteStructMember::common, OpenDDS::XTypes::CompleteStructMember::detail, OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::handle_tryconstruct_flags(), OpenDDS::XTypes::IS_EXTERNAL, OpenDDS::XTypes::IS_KEY, OpenDDS::XTypes::IS_MUST_UNDERSTAND, OpenDDS::XTypes::IS_OPTIONAL, OpenDDS::XTypes::CommonStructMember::member_flags, OpenDDS::XTypes::CommonStructMember::member_id, OpenDDS::XTypes::CommonStructMember::member_type_id, and OpenDDS::XTypes::CompleteMemberDetail::name.

 {
   DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
   md->name(cm.detail.name.c_str());
   md->id(cm.common.member_id);
   DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.member_type_id, guid);
   md->type(dt);
   handle_tryconstruct_flags(md, cm.common.member_flags);
   md->is_key(cm.common.member_flags & IS_KEY);
   md->is_optional(cm.common.member_flags & IS_OPTIONAL);
   md->is_must_understand(cm.common.member_flags & IS_MUST_UNDERSTAND);
   md->is_shared(cm.common.member_flags & IS_EXTERNAL);
   md->is_default_label(false);
   return md._retn();
 }

◆ complete_to_dynamic()

DDS::DynamicType_ptr OpenDDS::XTypes::TypeLookupService::complete_to_dynamic	(	const CompleteTypeObject &	cto,
		const DCPS::GUID_t &	guid
	)

Definition at line 666 of file TypeLookupService.cpp.

References DDS::APPENDABLE, DDS::FINAL, OpenDDS::XTypes::IS_APPENDABLE, OpenDDS::XTypes::IS_MUTABLE, and DDS::MUTABLE.

 {
   DynamicTypeImpl* dt = new DynamicTypeImpl();
   DDS::DynamicType_var dt_var = dt;
   complete_to_dynamic_i(dt, cto, guid);
   return dt_var._retn();
 }

◆ complete_to_dynamic_i()

void OpenDDS::XTypes::TypeLookupService::complete_to_dynamic_i	(	DynamicTypeImpl *	dt,
		const CompleteTypeObject &	cto,
		const DCPS::GUID_t &	guid
	)

private

Definition at line 689 of file TypeLookupService.cpp.

 {
   DDS::TypeDescriptor_var td = new TypeDescriptorImpl();
   switch (cto.kind) {
   case TK_ALIAS: {
     td->kind(TK_ALIAS);
     td->name(cto.alias_type.header.detail.type_name.c_str());
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.alias_type.body.common.related_type, guid);
     td->base_type(temp);
     // The spec says that Alias DynamicTypes should have DynamicTypeMembers, but that leads to redundancy
     }
     break;
   case TK_ENUM:
     td->kind(TK_ENUM);
     td->name(cto.enumerated_type.header.detail.type_name.c_str());
     if ((cto.enumerated_type.enum_flags & TypeFlagMinimalMask) == 0) {
       td->extensibility_kind(DDS::APPENDABLE);
     } else {
       td->extensibility_kind(type_flags_to_extensibility(cto.enumerated_type.enum_flags));
     }
     td->bound().length(1);
     td->bound()[0] = cto.enumerated_type.header.common.bit_bound;
     for (ACE_CDR::ULong i = 0; i < cto.enumerated_type.literal_seq.length(); ++i) {
       DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
       DDS::DynamicTypeMember_var dtm_var = dtm;
       MemberDescriptorImpl* md = new MemberDescriptorImpl();
       DDS::MemberDescriptor_var md_var = md;
       md->name(cto.enumerated_type.literal_seq[i].detail.name.c_str());
       // Use Id to convey the value of the enumerator.
       md->id(cto.enumerated_type.literal_seq[i].common.value);
       md->type(dt);
       md->is_default_label(cto.enumerated_type.literal_seq[i].common.flags & IS_DEFAULT);
       md->index(i);
       dtm->set_descriptor(md);
       dt->insert_dynamic_member(dtm);
     }
     break;
   case TK_BITMASK: {
     td->kind(TK_BITMASK);
     td->name(cto.bitmask_type.header.detail.type_name.c_str());
     td->extensibility_kind(type_flags_to_extensibility(cto.bitmask_type.bitmask_flags));
     td->bound().length(1);
     td->bound()[0] = cto.bitmask_type.header.common.bit_bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_BOOLEAN), guid);
     td->element_type(temp);
     for (ACE_CDR::ULong i = 0; i < cto.bitmask_type.flag_seq.length(); ++i) {
       DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
       DDS::DynamicTypeMember_var dtm_var = dtm;
       MemberDescriptorImpl* md = new MemberDescriptorImpl();
       DDS::MemberDescriptor_var md_var = md;
       md->name(cto.bitmask_type.flag_seq[i].detail.name.c_str());
       const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_BOOLEAN), guid);
       md->type(temp);
       md->index(i);
       dtm->set_descriptor(md);
       dt->insert_dynamic_member(dtm);
     }
     }
     break;
   case TK_ANNOTATION:
     td->kind(TK_ANNOTATION);
     td->name(cto.annotation_type.header.annotation_name.c_str());
     for (ACE_CDR::ULong i = 0; i < cto.annotation_type.member_seq.length(); ++i) {
       DDS::MemberDescriptor_var md = complete_annotation_member_to_member_descriptor(cto.annotation_type.member_seq[i], guid);
       md->index(i);
       md->id(i);
       DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
       DDS::DynamicTypeMember_var dtm_var = dtm;
       dtm->set_descriptor(md);
       dt->insert_dynamic_member(dtm);
     }
     break;
   case TK_STRUCTURE: {
     td->kind(TK_STRUCTURE);
     td->name(cto.struct_type.header.detail.type_name.c_str());
     if (cto.struct_type.header.base_type.kind() != TK_NONE) {
       const DDS::DynamicType_var base = type_identifier_to_dynamic(cto.struct_type.header.base_type, guid);
       td->base_type(base);
     }
     td->extensibility_kind(type_flags_to_extensibility(cto.struct_type.struct_flags));
     td->is_nested(cto.struct_type.struct_flags & IS_NESTED);
     for (ACE_CDR::ULong i = 0; i < cto.struct_type.member_seq.length(); ++i) {
       DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
       DDS::DynamicTypeMember_var dtm_var = dtm;
       DDS::MemberDescriptor_var md = complete_struct_member_to_member_descriptor(cto.struct_type.member_seq[i], guid);
       md->index(i);
       dtm->set_descriptor(md);
       dt->insert_dynamic_member(dtm);
     }
     }
     break;
   case TK_UNION: {
     td->kind(TK_UNION);
     td->name(cto.union_type.header.detail.type_name.c_str());
     td->extensibility_kind(type_flags_to_extensibility(cto.union_type.union_flags));
     td->is_nested(cto.union_type.union_flags & IS_NESTED);
 
     const DDS::DynamicType_var disc_type =
       type_identifier_to_dynamic(cto.union_type.discriminator.common.type_id, guid);
     td->discriminator_type(disc_type);
     DDS::MemberDescriptor_var disc_md = new MemberDescriptorImpl();
     disc_md->name("discriminator");
     disc_md->is_key(cto.union_type.discriminator.common.member_flags & IS_KEY);
     disc_md->type(disc_type);
     disc_md->id(DISCRIMINATOR_ID);
     disc_md->index(DISCRIMINATOR_ID);
     DynamicTypeMemberImpl* disc_dtm = new DynamicTypeMemberImpl();
     DDS::DynamicTypeMember_var disc_dtm_var = disc_dtm;
     disc_dtm->set_descriptor(disc_md);
     dt->insert_dynamic_member(disc_dtm);
 
     for (ACE_CDR::ULong i = 0; i < cto.union_type.member_seq.length(); ++i) {
       DDS::MemberDescriptor_var md = complete_union_member_to_member_descriptor(cto.union_type.member_seq[i], guid);
       md->index(i);
       DynamicTypeMemberImpl* dtm = new DynamicTypeMemberImpl();
       DDS::DynamicTypeMember_var dtm_var = dtm;
       dtm->set_descriptor(md);
       dt->insert_dynamic_member(dtm);
     }
     }
     break;
   case TK_BITSET:
     td->kind(TK_BITSET);
     td->name(cto.bitset_type.header.detail.type_name.c_str());
     break;
   case TK_SEQUENCE: {
     td->kind(TK_SEQUENCE);
     if (cto.sequence_type.header.detail) {
       td->name(cto.sequence_type.header.detail.value().type_name.c_str());
     }
     td->bound().length(1);
     td->bound()[0] = cto.sequence_type.header.common.bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.sequence_type.element.common.type, guid);
     td->element_type(temp);
     }
     break;
   case TK_ARRAY: {
     td->kind(TK_ARRAY);
     td->name(cto.array_type.header.detail.type_name.c_str());
     // FUTURE:  Have the TypeObject code use DDS::BoundSeq
     DDS::BoundSeq bounds;
     bounds.length(cto.array_type.header.common.bound_seq.length());
     for (unsigned int idx = 0; idx != bounds.length(); ++idx) {
       bounds[idx] = cto.array_type.header.common.bound_seq[idx];
     }
     td->bound(bounds);
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(cto.array_type.element.common.type, guid);
     td->element_type(temp);
     }
     break;
   case TK_MAP: {
     td->kind(TK_MAP);
     if (cto.map_type.header.detail) {
       td->name(cto.map_type.header.detail.value().type_name.c_str());
     }
     td->bound().length(1);
     td->bound()[0] = cto.map_type.header.common.bound;
     const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(cto.map_type.element.common.type, guid);
     td->element_type(el_temp);
     const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(cto.map_type.key.common.type, guid);
     td->key_element_type(key_temp);
     }
     break;
   }
   dt->set_descriptor(td);
 }

◆ complete_to_minimal_alias()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_alias	(	const CompleteAliasType &	ct,
		MinimalAliasType &	mt
	)		const

private

Definition at line 486 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteAliasType::alias_flags, OpenDDS::XTypes::MinimalAliasType::alias_flags, OpenDDS::XTypes::CompleteAliasType::body, OpenDDS::XTypes::MinimalAliasType::body, OpenDDS::XTypes::CompleteAliasBody::common, OpenDDS::XTypes::MinimalAliasBody::common, OpenDDS::XTypes::CommonAliasBody::related_flags, and OpenDDS::XTypes::CommonAliasBody::related_type.

 {
   mt.alias_flags = ct.alias_flags;
   mt.body.common.related_flags = ct.body.common.related_flags;
   if (!get_minimal_type_identifier(ct.body.common.related_type,
                                    mt.body.common.related_type)) {
     return false;
   }
   return true;
 }

◆ complete_to_minimal_annotation()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_annotation	(	const CompleteAnnotationType &	ct,
		MinimalAnnotationType &	mt
	)		const

private

Definition at line 468 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteAnnotationType::annotation_flag, OpenDDS::XTypes::MinimalAnnotationType::annotation_flag, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::CompleteAnnotationType::member_seq, and OpenDDS::XTypes::MinimalAnnotationType::member_seq.

 {
   mt.annotation_flag = ct.annotation_flag;
   mt.member_seq.length(ct.member_seq.length());
 
   for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
     mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
     if (!get_minimal_type_identifier(ct.member_seq[i].common.member_type_id,
                                      mt.member_seq[i].common.member_type_id)) {
       return false;
     }
     hash_member_name(mt.member_seq[i].name_hash, ct.member_seq[i].name);
     mt.member_seq[i].default_value = ct.member_seq[i].default_value;
   }
   return true;
 }

◆ complete_to_minimal_array()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_array	(	const CompleteArrayType &	ct,
		MinimalArrayType &	mt
	)		const

private

Definition at line 510 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteArrayType::collection_flag, OpenDDS::XTypes::MinimalArrayType::collection_flag, OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::XTypes::CompleteArrayHeader::common, OpenDDS::XTypes::MinimalArrayHeader::common, OpenDDS::XTypes::CompleteArrayType::element, OpenDDS::XTypes::MinimalArrayType::element, OpenDDS::XTypes::CommonCollectionElement::element_flags, OpenDDS::XTypes::CompleteArrayType::header, OpenDDS::XTypes::MinimalArrayType::header, and OpenDDS::XTypes::CommonCollectionElement::type.

 {
   mt.collection_flag = ct.collection_flag;
   mt.header.common = ct.header.common;
   mt.element.common.element_flags = ct.element.common.element_flags;
   if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
     return false;
   }
   return true;
 }

◆ complete_to_minimal_bitmask()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_bitmask	(	const CompleteBitmaskType &	ct,
		MinimalBitmaskType &	mt
	)		const

private

Definition at line 551 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteBitmaskType::bitmask_flags, OpenDDS::XTypes::MinimalBitmaskType::bitmask_flags, OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::MinimalEnumeratedHeader::common, OpenDDS::XTypes::CompleteBitmaskType::flag_seq, OpenDDS::XTypes::MinimalBitmaskType::flag_seq, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteBitmaskType::header, OpenDDS::XTypes::MinimalBitmaskType::header, and OpenDDS::XTypes::Sequence< T >::length().

 {
   mt.bitmask_flags = ct.bitmask_flags;
   mt.header.common = ct.header.common;
   mt.flag_seq.length(ct.flag_seq.length());
   for (ACE_CDR::ULong i = 0; i < ct.flag_seq.length(); ++i) {
     mt.flag_seq[i].common = ct.flag_seq[i].common;
     hash_member_name(mt.flag_seq[i].detail.name_hash, ct.flag_seq[i].detail.name);
   }
   return true;
 }

◆ complete_to_minimal_bitset()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_bitset	(	const CompleteBitsetType &	ct,
		MinimalBitsetType &	mt
	)		const

private

Definition at line 564 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteBitsetType::bitset_flags, OpenDDS::XTypes::MinimalBitsetType::bitset_flags, OpenDDS::XTypes::CompleteBitsetType::field_seq, OpenDDS::XTypes::MinimalBitsetType::field_seq, OpenDDS::XTypes::hash_member_name(), and OpenDDS::XTypes::Sequence< T >::length().

 {
   mt.bitset_flags = ct.bitset_flags;
   mt.field_seq.length(ct.field_seq.length());
   for (ACE_CDR::ULong i = 0; i < ct.field_seq.length(); ++i) {
     mt.field_seq[i].common = ct.field_seq[i].common;
     hash_member_name(mt.field_seq[i].name_hash, ct.field_seq[i].detail.name);
   }
   return true;
 }

◆ complete_to_minimal_enumerated()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_enumerated	(	const CompleteEnumeratedType &	ct,
		MinimalEnumeratedType &	mt
	)		const

private

Definition at line 538 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::MinimalEnumeratedHeader::common, OpenDDS::XTypes::CompleteEnumeratedType::enum_flags, OpenDDS::XTypes::MinimalEnumeratedType::enum_flags, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteEnumeratedType::header, OpenDDS::XTypes::MinimalEnumeratedType::header, OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::CompleteEnumeratedType::literal_seq, and OpenDDS::XTypes::MinimalEnumeratedType::literal_seq.

 {
   mt.enum_flags = ct.enum_flags;
   mt.header.common = ct.header.common;
   mt.literal_seq.length(ct.literal_seq.length());
   for (ACE_CDR::ULong i = 0; i < ct.literal_seq.length(); ++i) {
     mt.literal_seq[i].common = ct.literal_seq[i].common;
     hash_member_name(mt.literal_seq[i].detail.name_hash, ct.literal_seq[i].detail.name);
   }
   return true;
 }

◆ complete_to_minimal_map()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_map	(	const CompleteMapType &	ct,
		MinimalMapType &	mt
	)		const

private

Definition at line 522 of file TypeLookupService.cpp.

 {
   mt.collection_flag = ct.collection_flag;
   mt.header.common = ct.header.common;
   mt.key.common.element_flags = ct.key.common.element_flags;
   if (!get_minimal_type_identifier(ct.key.common.type, mt.key.common.type)) {
     return false;
   }
   mt.element.common.element_flags = ct.element.common.element_flags;
   if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
     return false;
   }
   return true;
 }

◆ complete_to_minimal_sequence()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_sequence	(	const CompleteSequenceType &	ct,
		MinimalSequenceType &	mt
	)		const

private

Definition at line 498 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteSequenceType::collection_flag, OpenDDS::XTypes::MinimalSequenceType::collection_flag, OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::XTypes::CompleteCollectionHeader::common, OpenDDS::XTypes::MinimalCollectionHeader::common, OpenDDS::XTypes::CompleteSequenceType::element, OpenDDS::XTypes::MinimalSequenceType::element, OpenDDS::XTypes::CommonCollectionElement::element_flags, OpenDDS::XTypes::CompleteSequenceType::header, OpenDDS::XTypes::MinimalSequenceType::header, and OpenDDS::XTypes::CommonCollectionElement::type.

 {
   mt.collection_flag = ct.collection_flag;
   mt.header.common = ct.header.common;
   mt.element.common.element_flags = ct.element.common.element_flags;
   if (!get_minimal_type_identifier(ct.element.common.type, mt.element.common.type)) {
     return false;
   }
   return true;
 }

◆ complete_to_minimal_struct()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_struct	(	const CompleteStructType &	ct,
		MinimalStructType &	mt
	)		const

private

Definition at line 423 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteStructHeader::base_type, OpenDDS::XTypes::MinimalStructHeader::base_type, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteStructType::header, OpenDDS::XTypes::MinimalStructType::header, OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::CompleteStructType::member_seq, OpenDDS::XTypes::MinimalStructType::member_seq, OpenDDS::XTypes::CompleteStructType::struct_flags, and OpenDDS::XTypes::MinimalStructType::struct_flags.

 {
   mt.struct_flags = ct.struct_flags;
   if (!get_minimal_type_identifier(ct.header.base_type, mt.header.base_type)) {
     return false;
   }
   mt.member_seq.length(ct.member_seq.length());
 
   for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
     mt.member_seq[i].common.member_id = ct.member_seq[i].common.member_id;
     mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
     if (!get_minimal_type_identifier(ct.member_seq[i].common.member_type_id,
                                      mt.member_seq[i].common.member_type_id)) {
       return false;
     }
     hash_member_name(mt.member_seq[i].detail.name_hash, ct.member_seq[i].detail.name);
   }
   return true;
 }

◆ complete_to_minimal_type_object()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_type_object	(	const TypeObject &	cto,
		TypeObject &	mto
	)		const

For converting between complete to minimal TypeObject of remote types

Definition at line 576 of file TypeLookupService.cpp.

 {
   mto.kind = EK_MINIMAL;
   mto.minimal.kind = cto.complete.kind;
 
   switch (cto.complete.kind) {
   case TK_ALIAS:
     return complete_to_minimal_alias(cto.complete.alias_type, mto.minimal.alias_type);
   case TK_ANNOTATION:
     return complete_to_minimal_annotation(cto.complete.annotation_type, mto.minimal.annotation_type);
   case TK_STRUCTURE:
     return complete_to_minimal_struct(cto.complete.struct_type, mto.minimal.struct_type);
   case TK_UNION:
     return complete_to_minimal_union(cto.complete.union_type, mto.minimal.union_type);
   case TK_BITSET:
     return complete_to_minimal_bitset(cto.complete.bitset_type, mto.minimal.bitset_type);
   case TK_SEQUENCE:
     return complete_to_minimal_sequence(cto.complete.sequence_type, mto.minimal.sequence_type);
   case TK_ARRAY:
     return complete_to_minimal_array(cto.complete.array_type, mto.minimal.array_type);
   case TK_MAP:
     return complete_to_minimal_map(cto.complete.map_type, mto.minimal.map_type);
   case TK_ENUM:
     return complete_to_minimal_enumerated(cto.complete.enumerated_type, mto.minimal.enumerated_type);
   case TK_BITMASK:
     return complete_to_minimal_bitmask(cto.complete.bitmask_type, mto.minimal.bitmask_type);
   default:
     return false;
   }
 }

◆ complete_to_minimal_union()

bool OpenDDS::XTypes::TypeLookupService::complete_to_minimal_union	(	const CompleteUnionType &	ct,
		MinimalUnionType &	mt
	)		const

private

Definition at line 444 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteDiscriminatorMember::common, OpenDDS::XTypes::MinimalDiscriminatorMember::common, OpenDDS::XTypes::CompleteUnionType::discriminator, OpenDDS::XTypes::MinimalUnionType::discriminator, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::CommonDiscriminatorMember::member_flags, OpenDDS::XTypes::CompleteUnionType::member_seq, OpenDDS::XTypes::MinimalUnionType::member_seq, OpenDDS::XTypes::CommonDiscriminatorMember::type_id, OpenDDS::XTypes::CompleteUnionType::union_flags, and OpenDDS::XTypes::MinimalUnionType::union_flags.

 {
   mt.union_flags = ct.union_flags;
   mt.discriminator.common.member_flags = ct.discriminator.common.member_flags;
   if (!get_minimal_type_identifier(ct.discriminator.common.type_id,
                                    mt.discriminator.common.type_id)) {
     return false;
   }
   mt.member_seq.length(ct.member_seq.length());
 
   for (ACE_CDR::ULong i = 0; i < ct.member_seq.length(); ++i) {
     mt.member_seq[i].common.member_id = ct.member_seq[i].common.member_id;
     mt.member_seq[i].common.member_flags = ct.member_seq[i].common.member_flags;
     if (!get_minimal_type_identifier(ct.member_seq[i].common.type_id,
                                      mt.member_seq[i].common.type_id)) {
       return false;
     }
     mt.member_seq[i].common.label_seq = ct.member_seq[i].common.label_seq;
     hash_member_name(mt.member_seq[i].detail.name_hash, ct.member_seq[i].detail.name);
   }
   return true;
 }

◆ complete_union_member_to_member_descriptor()

DDS::MemberDescriptor * OpenDDS::XTypes::TypeLookupService::complete_union_member_to_member_descriptor	(	const CompleteUnionMember &	cm,
		const DCPS::GUID_t &	guid
	)

private

Definition at line 625 of file TypeLookupService.cpp.

References OpenDDS::XTypes::CompleteUnionMember::common, OpenDDS::XTypes::CompleteUnionMember::detail, OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL::handle_tryconstruct_flags(), OpenDDS::XTypes::IS_DEFAULT, OpenDDS::XTypes::IS_EXTERNAL, OpenDDS::XTypes::CommonUnionMember::label_seq, OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::CommonUnionMember::member_flags, OpenDDS::XTypes::CommonUnionMember::member_id, OpenDDS::XTypes::CompleteMemberDetail::name, and OpenDDS::XTypes::CommonUnionMember::type_id.

 {
   DDS::MemberDescriptor_var md = new MemberDescriptorImpl();
   md->name(cm.detail.name.c_str());
   md->id(cm.common.member_id);
   DDS::DynamicType_var dt = type_identifier_to_dynamic(cm.common.type_id, guid);
   md->type(dt);
   // Make a copy.
   // FUTURE:  Have the TypeObject code use DDS::UnionCaseLabelSeq
   DDS::UnionCaseLabelSeq labels;
   labels.length(cm.common.label_seq.length());
   for (unsigned int idx = 0; idx != labels.length(); ++idx) {
     labels[idx] = cm.common.label_seq[idx];
   }
   md->label(labels);
   handle_tryconstruct_flags(md, cm.common.member_flags);
   md->is_key(false);
   md->is_optional(false);
   md->is_must_understand(false);
   md->is_shared(cm.common.member_flags & IS_EXTERNAL);
   md->is_default_label(cm.common.member_flags & IS_DEFAULT);
   return md._retn();
 }

◆ extensibility()

bool OpenDDS::XTypes::TypeLookupService::extensibility	(	TypeFlag	extensibility_mask,
		const TypeIdentifier &	ti
	)		const

Definition at line 1117 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN, OpenDDS::XTypes::Sequence< T >::append(), OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::TypeObject::minimal, OpenDDS::XTypes::CompleteStructType::struct_flags, OpenDDS::XTypes::MinimalStructType::struct_flags, OpenDDS::XTypes::CompleteTypeObject::struct_type, OpenDDS::XTypes::MinimalTypeObject::struct_type, OpenDDS::XTypes::TK_STRUCTURE, OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::CompleteUnionType::union_flags, OpenDDS::XTypes::MinimalUnionType::union_flags, OpenDDS::XTypes::CompleteTypeObject::union_type, and OpenDDS::XTypes::MinimalTypeObject::union_type.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
   bool result = false;
   const TypeObject& to = get_type_object_i(type_id);
   TypeKind tk = to.kind == EK_MINIMAL ? to.minimal.kind : to.complete.kind;
 
   if (TK_UNION == tk) {
     result = to.kind == EK_MINIMAL ?
       (to.minimal.union_type.union_flags & extensibility_mask) :
       (to.complete.union_type.union_flags & extensibility_mask);
   } else if (TK_STRUCTURE == tk) {
     result = to.kind == EK_MINIMAL ?
       (to.minimal.struct_type.struct_flags & extensibility_mask) :
       (to.complete.struct_type.struct_flags & extensibility_mask);
   }
 
   if (result) {
     return true;
   }
 
   TypeIdentifierWithSizeSeq dependencies;
   TypeIdentifierSeq type_ids;
   type_ids.append(type_id);
   get_type_dependencies_i(type_ids, dependencies);
 
   for (unsigned i = 0; i < dependencies.length(); ++i) {
     const TypeObject& dep_to = get_type_object_i(dependencies[i].type_id);
     tk = dep_to.kind == EK_MINIMAL ? dep_to.minimal.kind : dep_to.complete.kind;
 
     if (TK_UNION == tk) {
       result = dep_to.kind == EK_MINIMAL ?
         (dep_to.minimal.union_type.union_flags & extensibility_mask) :
         (dep_to.complete.union_type.union_flags & extensibility_mask);
     } else if (TK_STRUCTURE == tk) {
       result = dep_to.kind == EK_MINIMAL ?
         (dep_to.minimal.struct_type.struct_flags & extensibility_mask) :
         (dep_to.complete.struct_type.struct_flags & extensibility_mask);
     }
     if (result) {
       return true;
     }
   }
   return false;
 }

◆ get_minimal_type_identifier()

bool OpenDDS::XTypes::TypeLookupService::get_minimal_type_identifier	(	const TypeIdentifier &	ct,
		TypeIdentifier &	mt
	)		const

private

Definition at line 185 of file TypeLookupService.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::equivalence_hash_to_string(), OpenDDS::XTypes::is_fully_descriptive(), OpenDDS::XTypes::is_plain_collection(), OpenDDS::XTypes::TypeIdentifier::kind(), LM_ERROR, OpenDDS::XTypes::TI_PLAIN_ARRAY_LARGE, OpenDDS::XTypes::TI_PLAIN_ARRAY_SMALL, OpenDDS::XTypes::TI_PLAIN_MAP_LARGE, OpenDDS::XTypes::TI_PLAIN_MAP_SMALL, OpenDDS::XTypes::TI_PLAIN_SEQUENCE_LARGE, OpenDDS::XTypes::TI_PLAIN_SEQUENCE_SMALL, OpenDDS::XTypes::TI_STRONGLY_CONNECTED_COMPONENT, and OpenDDS::XTypes::TK_NONE.

 {
   if (ct.kind() == TK_NONE || is_fully_descriptive(ct)) {
     mt = ct;
     return true;
   }
 
   // Non-fully descriptive plain collection is a special case where we have to
   // get the minimal TypeIdentifier of the element type to create the TypeIdentifier
   // of the minimal collection type.
   if (is_plain_collection(ct)) {
     mt = ct;
     TypeIdentifier complete_elem_ti, minimal_elem_ti;
     switch (mt.kind()) {
     case TI_PLAIN_SEQUENCE_SMALL:
       mt.seq_sdefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.seq_sdefn().element_identifier;
       break;
     case TI_PLAIN_SEQUENCE_LARGE:
       mt.seq_ldefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.seq_ldefn().element_identifier;
       break;
     case TI_PLAIN_ARRAY_SMALL:
       mt.array_sdefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.array_sdefn().element_identifier;
       break;
     case TI_PLAIN_ARRAY_LARGE:
       mt.array_ldefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.array_ldefn().element_identifier;
       break;
     case TI_PLAIN_MAP_SMALL:
       mt.map_sdefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.map_sdefn().element_identifier;
       break;
     case TI_PLAIN_MAP_LARGE:
       mt.map_ldefn().header.equiv_kind = EK_MINIMAL;
       complete_elem_ti = *ct.map_ldefn().element_identifier;
       break;
     }
     get_minimal_type_identifier(complete_elem_ti, minimal_elem_ti);
 
     switch (mt.kind()) {
     case TI_PLAIN_SEQUENCE_SMALL:
       mt.seq_sdefn().element_identifier = minimal_elem_ti;
       break;
     case TI_PLAIN_SEQUENCE_LARGE:
       mt.seq_ldefn().element_identifier = minimal_elem_ti;
       break;
     case TI_PLAIN_ARRAY_SMALL:
       mt.array_sdefn().element_identifier = minimal_elem_ti;
       break;
     case TI_PLAIN_ARRAY_LARGE:
       mt.array_ldefn().element_identifier = minimal_elem_ti;
       break;
     case TI_PLAIN_MAP_SMALL:
       {
         mt.map_sdefn().element_identifier = minimal_elem_ti;
         TypeIdentifier minimal_key_ti;
         get_minimal_type_identifier(*ct.map_sdefn().key_identifier, minimal_key_ti);
         mt.map_sdefn().key_identifier = minimal_key_ti;
         break;
       }
     case TI_PLAIN_MAP_LARGE:
       {
         mt.map_ldefn().element_identifier = minimal_elem_ti;
         TypeIdentifier minimal_key_ti;
         get_minimal_type_identifier(*ct.map_ldefn().key_identifier, minimal_key_ti);
         mt.map_ldefn().key_identifier = minimal_key_ti;
         break;
       }
     }
 
     return true;
   }
 
   // Mapping for the remaining type kinds should be provided by the remote endpoint.
   const TypeIdentifierMap::const_iterator pos = complete_to_minimal_ti_map_.find(ct);
   if (pos == complete_to_minimal_ti_map_.end()) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
                ACE_TEXT("complete TypeIdentifier not found.\n")));
     if (ct.kind() == EK_COMPLETE) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
                  ACE_TEXT(" Kind: EK_COMPLETE. Hash: (%C)\n"),
                  equivalence_hash_to_string(ct.equivalence_hash()).c_str()));
     } else if (ct.kind() == TI_STRONGLY_CONNECTED_COMPONENT) {
       const EquivalenceKind ek = ct.sc_component_id().sc_component_id.kind;
       if (ek == EK_MINIMAL) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
                    ACE_TEXT("Expect EK_COMPLETE but received EK_MINIMAL.\n")));
       }
       const DCPS::String ek_str = ek == EK_COMPLETE ? "EK_COMPLETE" : "EK_MINIMAL";
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::get_minimal_type_identifier: ")
                  ACE_TEXT("Kind: TI_STRONGLY_CONNECTED_COMPONENT. ")
                  ACE_TEXT("Equivalence kind: %C. Hash: (%C). Scc length: %d. Scc index: %d\n"),
                  ek_str.c_str(),
                  equivalence_hash_to_string(ct.sc_component_id().sc_component_id.hash).c_str(),
                  ct.sc_component_id().scc_length,
                  ct.sc_component_id().scc_index));
     }
 
     mt = TypeIdentifier(TK_NONE);
     return false;
   }
   mt = pos->second;
   return true;
 }

◆ get_type_dependencies() [1/2]

bool OpenDDS::XTypes::TypeLookupService::get_type_dependencies	(	const TypeIdentifier &	type_id,
		TypeIdentifierWithSizeSeq &	dependencies
	)		const

For TypeLookup_getTypeDependencies.

Definition at line 84 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
   const TypeIdentifierWithSizeSeqMap::const_iterator it = type_dependencies_map_.find(type_id);
   if (it != type_dependencies_map_.end()) {
     dependencies = it->second;
     return true;
   }
   return false;
 }

◆ get_type_dependencies() [2/2]

void OpenDDS::XTypes::TypeLookupService::get_type_dependencies	(	const TypeIdentifierSeq &	type_ids,
		TypeIdentifierWithSizeSeq &	dependencies
	)		const

Definition at line 96 of file TypeLookupService.cpp.

References ACE_GUARD.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   get_type_dependencies_i(type_ids, dependencies);
 }

◆ get_type_dependencies_i()

void OpenDDS::XTypes::TypeLookupService::get_type_dependencies_i	(	const TypeIdentifierSeq &	type_ids,
		TypeIdentifierWithSizeSeq &	dependencies
	)		const

private

Definition at line 103 of file TypeLookupService.cpp.

References OpenDDS::XTypes::get_typeobject_encoding(), OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::OPENDDS_SET(), and OpenDDS::DCPS::serialized_size().

 {
   OPENDDS_SET(TypeIdentifier) tmp;
   for (unsigned i = 0; i < type_ids.length(); ++i) {
     const TypeIdentifierWithSizeSeqMap::const_iterator it = type_dependencies_map_.find(type_ids[i]);
     if (it != type_dependencies_map_.end()) {
       for (unsigned j = 0; j < it->second.length(); ++j) {
         tmp.insert(it->second[j].type_id);
       }
     }
   }
 
   // All dependent TypeIdentifiers are expected to have an entry in the TypeObject cache.
   dependencies.length(static_cast<unsigned>(tmp.size()));
   OPENDDS_SET(TypeIdentifier)::const_iterator iter = tmp.begin();
   for (unsigned i = 0; iter != tmp.end(); ++i, ++iter) {
     const TypeMap::const_iterator tobj_it = type_map_.find(*iter);
     if (tobj_it != type_map_.end()) {
       dependencies[i].type_id = *iter;
       const size_t sz = DCPS::serialized_size(get_typeobject_encoding(), tobj_it->second);
       dependencies[i].typeobject_serialized_size = static_cast<unsigned>(sz);
     }
   }
 }

◆ get_type_info()

const TypeInformation & OpenDDS::XTypes::TypeLookupService::get_type_info ( const DDS::BuiltinTopicKey_t & key ) const

Definition at line 175 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, type_info_empty_);
   const TypeInformationMap::const_iterator it = type_info_map_.find(key);
   if (it != type_info_map_.end()) {
     return it->second;
   }
   return type_info_empty_;
 }

◆ get_type_object()

const TypeObject & OpenDDS::XTypes::TypeLookupService::get_type_object ( const TypeIdentifier & type_id ) const

For TypeAssignability.

Definition at line 69 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, to_empty_);
   return get_type_object_i(type_id);
 }

◆ get_type_object_i()

const TypeObject & OpenDDS::XTypes::TypeLookupService::get_type_object_i ( const TypeIdentifier & type_id ) const

private

Definition at line 75 of file TypeLookupService.cpp.

 {
   const TypeMap::const_iterator pos = type_map_.find(type_id);
   if (pos != type_map_.end()) {
     return pos->second;
   }
   return to_empty_;
 }

◆ get_type_objects()

void OpenDDS::XTypes::TypeLookupService::get_type_objects	(	const TypeIdentifierSeq &	type_ids,
		TypeIdentifierTypeObjectPairSeq &	types
	)		const

For TypeLookup_getTypes.

Definition at line 57 of file TypeLookupService.cpp.

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

 {
   ACE_GUARD(ACE_Thread_Mutex, g, mutex_);
   for (unsigned i = 0; i < type_ids.length(); ++i) {
     TypeMap::const_iterator pos = type_map_.find(type_ids[i]);
     if (pos != type_map_.end()) {
       types.append(TypeIdentifierTypeObjectPair(pos->first, pos->second));
     }
   }
 }

◆ has_complete()

bool OpenDDS::XTypes::TypeLookupService::has_complete ( const TypeIdentifier & ti ) const

Definition at line 1180 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::TypeIdentifier::kind(), and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
   return ti.kind() == EK_COMPLETE && type_map_.count(ti);
 }

◆ OPENDDS_MAP() [1/4]

typedef OpenDDS::XTypes::TypeLookupService::OPENDDS_MAP	(	TypeIdentifier	,
		DDS::DynamicType_var
	)

◆ OPENDDS_MAP() [2/4]

typedef OpenDDS::XTypes::TypeLookupService::OPENDDS_MAP	(	DCPS::GUID_t	,
		DynamicTypeMap
	)

◆ OPENDDS_MAP() [3/4]

typedef OpenDDS::XTypes::TypeLookupService::OPENDDS_MAP	(	TypeIdentifier	,
		TypeIdentifierWithSizeSeq
	)

private

For dependencies of local types.

◆ OPENDDS_MAP() [4/4]

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

private

Mapping from complete to minimal TypeIdentifiers of dependencies of remote types.

◆ OPENDDS_MAP_CMP()

typedef OpenDDS::XTypes::TypeLookupService::OPENDDS_MAP_CMP	(	DDS::BuiltinTopicKey_t	,
		TypeInformation	,
		DCPS::BuiltinTopicKey_tKeyLessThan
	)

private

Map from BuiltinTopicKey_t of remote endpoint to its TypeInformation.

◆ remove_guid_from_dynamic_map()

void OpenDDS::XTypes::TypeLookupService::remove_guid_from_dynamic_map ( const DCPS::GUID_t & guid )

Definition at line 1164 of file TypeLookupService.cpp.

References ACE_DEBUG, OpenDDS::DCPS::DCPS_debug_level, LM_DEBUG, and OpenDDS::DCPS::to_string().

 {
   ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
   const GuidTypeMap::iterator g_found = gt_map_.find(guid);
   if (g_found != gt_map_.end()) {
     for (DynamicTypeMap::const_iterator pos2 = g_found->second.begin(), limit2 = g_found->second.end(); pos2 != limit2; ++pos2) {
       pos2->second->clear();
     }
     gt_map_.erase(g_found);
     if (DCPS::DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) TypeLookupService::remove_guid_from_dynamic_map: ",
         "Alerted to removal of %C, removing GUID from GuidTypeMap.\n", DCPS::to_string(guid).c_str()));
     }
   }
 }

◆ set_type_object_defaults()

bool OpenDDS::XTypes::TypeLookupService::set_type_object_defaults ( TypeObject & to )

private

Definition at line 292 of file TypeLookupService.cpp.

 {
   switch (to.minimal.kind) {
   case TK_STRUCTURE:
     {
       const TypeFlag flags = to.minimal.struct_type.struct_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_STRUCTURE\n"));
         }
         return false;
       }
     }
     break;
   case TK_UNION:
     {
       const TypeFlag flags = to.minimal.union_type.union_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_UNION\n"));
         }
         return false;
       }
     }
     break;
   case TK_ENUM:
     {
       const TypeFlag flags = to.minimal.enumerated_type.enum_flags & TypeFlagMinimalMask;
       // flags == 0 is for backwards compatibility.
       if (!(flags == 0 || flags == IS_FINAL || flags == IS_APPENDABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_ENUM\n"));
         }
         return false;
       }
       if (flags == 0 && DCPS::log_level >= DCPS::LogLevel::Warning) {
         ACE_ERROR((LM_WARNING,
                    "(%P|%t) WARNING: TypeLookupService::set_type_object_defaults: "
                    "Zero extensibility flags in TK_ENUM\n"));
       }
     }
     break;
   case TK_BITMASK:
     {
       const TypeFlag flags = to.minimal.bitmask_type.bitmask_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_BITMASK\n"));
         }
         return false;
       }
     }
     break;
   default:
     break;
   }
 
   switch (to.complete.kind) {
   case TK_STRUCTURE:
     {
       const TypeFlag flags = to.complete.struct_type.struct_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_STRUCTURE\n"));
         }
         return false;
       }
     }
     break;
   case TK_UNION:
     {
       const TypeFlag flags = to.complete.union_type.union_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE || flags == IS_MUTABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_UNION\n"));
         }
         return false;
       }
     }
     break;
   case TK_ENUM:
     {
       const TypeFlag flags = to.complete.enumerated_type.enum_flags & TypeFlagMinimalMask;
       // flags == 0 is for backwards compatibility.
       if (!(flags == 0 || flags == IS_FINAL || flags == IS_APPENDABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_ENUM\n"));
         }
         return false;
       }
       if (flags == 0 && DCPS::log_level >= DCPS::LogLevel::Warning) {
         ACE_ERROR((LM_WARNING,
                    "(%P|%t) WARNING: TypeLookupService::set_type_object_defaults: "
                    "Zero extensibility flags in TK_ENUM\n"));
       }
     }
     break;
   case TK_BITMASK:
     {
       const TypeFlag flags = to.complete.bitmask_type.bitmask_flags & TypeFlagMinimalMask;
       if (!(flags == IS_FINAL || flags == IS_APPENDABLE)) {
         if (DCPS::log_level >= DCPS::LogLevel::Error) {
           ACE_ERROR((LM_ERROR,
                      "(%P|%t) ERROR: TypeLookupService::set_type_object_defaults: "
                      "Invalid extensibility kind in TK_BITMASK\n"));
         }
         return false;
       }
     }
     break;
   default:
     break;
   }
 
   return true;
 }

◆ type_identifier_to_dynamic()

DDS::DynamicType_ptr OpenDDS::XTypes::TypeLookupService::type_identifier_to_dynamic	(	const TypeIdentifier &	ti,
		const DCPS::GUID_t &	guid
	)

Definition at line 858 of file TypeLookupService.cpp.

 {
   if (ti.kind() == TK_NONE) {
     if (DCPS::DCPS_debug_level >= 1) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
                  ACE_TEXT(" Encountered TK_NONE: returning nil Dynamic Type\n")));
     }
     return 0;
   }
   DynamicTypeImpl* dt = new DynamicTypeImpl();
   DDS::DynamicType_var dt_var = dt;
   DDS::TypeDescriptor_var td = new TypeDescriptorImpl();
   {
     ACE_Guard<ACE_Thread_Mutex> guard(mutex_);
     const GuidTypeMap::iterator guid_found = gt_map_.find(guid);
     if (guid_found != gt_map_.end()) {
       const DynamicTypeMap::const_iterator ti_found = guid_found->second.find(ti);
       if (ti_found != guid_found->second.end()) {
         return DDS::DynamicType::_duplicate(ti_found->second);
       } else {
         guid_found->second.insert(std::make_pair(ti, dt_var));
       }
     } else {
       DynamicTypeMap dt_map;
       dt_map.insert(std::make_pair(ti, dt_var));
       gt_map_.insert(std::make_pair(guid, dt_map));
     }
   }
 
   switch (ti.kind()) {
   case TK_BOOLEAN:
     td->kind(TK_BOOLEAN);
     td->name("Boolean");
     dt->set_descriptor(td);
     break;
   case TK_BYTE:
     td->kind(TK_BYTE);
     td->name("Byte");
     dt->set_descriptor(td);
     break;
   case TK_INT16:
     td->kind(TK_INT16);
     td->name("Int16");
     dt->set_descriptor(td);
     break;
   case TK_INT32:
     td->kind(TK_INT32);
     td->name("Int32");
     dt->set_descriptor(td);
     break;
   case TK_INT64:
     td->kind(TK_INT64);
     td->name("Int64");
     dt->set_descriptor(td);
     break;
   case TK_UINT16:
     td->kind(TK_UINT16);
     td->name("UInt16");
     dt->set_descriptor(td);
     break;
   case TK_UINT32:
     td->kind(TK_UINT32);
     td->name("UInt32");
     dt->set_descriptor(td);
     break;
   case TK_UINT64:
     td->kind(TK_UINT64);
     td->name("UInt64");
     dt->set_descriptor(td);
     break;
   case TK_FLOAT32:
     td->kind(TK_FLOAT32);
     td->name("Float32");
     dt->set_descriptor(td);
     break;
   case TK_FLOAT64:
     td->kind(TK_FLOAT64);
     td->name("Float64");
     dt->set_descriptor(td);
     break;
   case TK_FLOAT128:
     td->kind(TK_FLOAT128);
     td->name("Float128");
     dt->set_descriptor(td);
     break;
   case TK_INT8:
     td->kind(TK_INT8);
     td->name("Int8");
     dt->set_descriptor(td);
     break;
   case TK_UINT8:
     td->kind(TK_UINT8);
     td->name("UInt8");
     dt->set_descriptor(td);
     break;
   case TK_CHAR8:
     td->kind(TK_CHAR8);
     td->name("Char8");
     dt->set_descriptor(td);
     break;
   case TK_CHAR16:
     td->kind(TK_CHAR16);
     td->name("Char16");
     dt->set_descriptor(td);
     break;
   case TI_STRING8_SMALL: {
     td->kind(TK_STRING8);
     td->name("String8");
     td->bound().length(1);
     td->bound()[0] = ti.string_sdefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR8), guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_STRING8_LARGE: {
     td->kind(TK_STRING8);
     td->name("String8");
     td->bound().length(1);
     td->bound()[0] = ti.string_ldefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR8), guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_STRING16_SMALL: {
     td->kind(TK_STRING16);
     td->name("WString16");
     td->bound().length(1);
     td->bound()[0] = ti.string_sdefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR16), guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_STRING16_LARGE: {
     td->kind(TK_STRING16);
     td->name("WString16");
     td->bound().length(1);
     td->bound()[0] = ti.string_ldefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(TypeIdentifier(TK_CHAR16), guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_SEQUENCE_SMALL: {
     td->kind(TK_SEQUENCE);
     td->name("Sequence");
     td->bound().length(1);
     td->bound()[0] = ti.seq_sdefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.seq_sdefn().element_identifier, guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_SEQUENCE_LARGE: {
     td->kind(TK_SEQUENCE);
     td->name("Sequence");
     td->bound().length(1);
     td->bound()[0] = ti.seq_ldefn().bound;
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.seq_ldefn().element_identifier, guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_ARRAY_SMALL: {
     td->kind(TK_ARRAY);
     td->name("Array");
     td->bound().length(ti.array_sdefn().array_bound_seq.length());
     for (ACE_CDR::ULong i = 0; i< td->bound().length(); ++i) {
       td->bound()[i] = ti.array_sdefn().array_bound_seq[i];
     }
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.array_sdefn().element_identifier, guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_ARRAY_LARGE: {
     td->kind(TK_ARRAY);
     td->name("Array");
     DDS::BoundSeq bounds;
     bounds.length(ti.array_ldefn().array_bound_seq.length());
     for (unsigned int idx = 0; idx != bounds.length(); ++idx) {
       bounds[idx] = ti.array_ldefn().array_bound_seq[idx];
     }
     td->bound(bounds);
     const DDS::DynamicType_var temp = type_identifier_to_dynamic(*ti.array_ldefn().element_identifier, guid);
     td->element_type(temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_MAP_SMALL: {
     td->kind(TK_MAP);
     td->name("Map");
     td->bound().length(1);
     td->bound()[0] = ti.map_sdefn().bound;
     const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(*ti.map_sdefn().element_identifier, guid);
     td->element_type(el_temp);
     const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(*ti.map_sdefn().key_identifier, guid);
     td->key_element_type(key_temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_PLAIN_MAP_LARGE: {
     td->kind(TK_MAP);
     td->name("Map");
     td->bound().length(1);
     td->bound()[0] = ti.map_ldefn().bound;
     const DDS::DynamicType_var el_temp = type_identifier_to_dynamic(*ti.map_ldefn().element_identifier, guid);
     td->element_type(el_temp);
     const DDS::DynamicType_var key_temp = type_identifier_to_dynamic(*ti.map_ldefn().key_identifier, guid);
     td->key_element_type(key_temp);
     dt->set_descriptor(td);
     }
     break;
   case TI_STRONGLY_CONNECTED_COMPONENT:
   case EK_COMPLETE:
     {
       const TypeObject& to = get_type_object_i(ti);
       if (to.kind == TK_NONE) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
                    ACE_TEXT(" get_type_object_i returned TK_NONE\n")));
       } else {
         complete_to_dynamic_i(dt, to.complete, guid);
       }
     }
     break;
   case EK_MINIMAL:
     if (DCPS::DCPS_debug_level >= 1) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) TypeLookupService::type_identifier_to_dynamic -")
                  ACE_TEXT(" Encountered EK_MINIMAL: returning nil Dynamic Type\n")));
     }
     break;
   case TK_ANNOTATION:
     td->kind(TK_ANNOTATION);
     td->name("Annotation");
     dt->set_descriptor(td);
     break;
   }
 
   return dt_var._retn();
 }

◆ type_object_in_cache()

bool OpenDDS::XTypes::TypeLookupService::type_object_in_cache ( const TypeIdentifier & ti ) const

Definition at line 1111 of file TypeLookupService.cpp.

References ACE_GUARD_RETURN.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, mutex_, false);
   return type_map_.find(ti) != type_map_.end();
 }

◆ update_type_identifier_map()

void OpenDDS::XTypes::TypeLookupService::update_type_identifier_map ( const TypeIdentifierPairSeq & tid_pairs )

For converting between complete to minimal TypeObject of remote types

Definition at line 158 of file TypeLookupService.cpp.

References OpenDDS::XTypes::Sequence< T >::length(), OpenDDS::XTypes::TypeIdentifierPair::type_identifier1, and OpenDDS::XTypes::TypeIdentifierPair::type_identifier2.

 {
   for (ACE_CDR::ULong i = 0; i < tid_pairs.length(); ++i) {
     const TypeIdentifierPair& pair = tid_pairs[i];
     complete_to_minimal_ti_map_.insert(std::make_pair(pair.type_identifier1, pair.type_identifier2));
   }
 }

Member Data Documentation

◆ complete_to_minimal_ti_map_

TypeIdentifierMap OpenDDS::XTypes::TypeLookupService::complete_to_minimal_ti_map_

private

Definition at line 95 of file TypeLookupService.h.

◆ gt_map_

GuidTypeMap OpenDDS::XTypes::TypeLookupService::gt_map_

private

Definition at line 118 of file TypeLookupService.h.

◆ mutex_

ACE_Thread_Mutex OpenDDS::XTypes::TypeLookupService::mutex_

mutableprivate

Definition at line 89 of file TypeLookupService.h.

◆ to_empty_

TypeObject OpenDDS::XTypes::TypeLookupService::to_empty_

private

Definition at line 91 of file TypeLookupService.h.

◆ type_dependencies_map_

TypeIdentifierWithSizeSeqMap OpenDDS::XTypes::TypeLookupService::type_dependencies_map_

private

Definition at line 87 of file TypeLookupService.h.

◆ type_info_empty_

TypeInformation OpenDDS::XTypes::TypeLookupService::type_info_empty_

private

Definition at line 124 of file TypeLookupService.h.

◆ type_info_map_

TypeInformationMap OpenDDS::XTypes::TypeLookupService::type_info_map_

private

Definition at line 123 of file TypeLookupService.h.

◆ type_map_

TypeMap OpenDDS::XTypes::TypeLookupService::type_map_

private

Contains both minimal and complete type mapping.

Definition at line 83 of file TypeLookupService.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TypeLookupService()

◆ ~TypeLookupService()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ add_type_dependencies()

◆ add_type_objects_to_cache()

◆ cache_type_info()

◆ complete_annotation_member_to_member_descriptor()

◆ complete_struct_member_to_member_descriptor()

◆ complete_to_dynamic()

◆ complete_to_dynamic_i()

◆ complete_to_minimal_alias()

◆ complete_to_minimal_annotation()

◆ complete_to_minimal_array()

◆ complete_to_minimal_bitmask()

◆ complete_to_minimal_bitset()

◆ complete_to_minimal_enumerated()

◆ complete_to_minimal_map()

◆ complete_to_minimal_sequence()

◆ complete_to_minimal_struct()

◆ complete_to_minimal_type_object()

◆ complete_to_minimal_union()

◆ complete_union_member_to_member_descriptor()

◆ extensibility()

◆ get_minimal_type_identifier()

◆ get_type_dependencies() [1/2]

◆ get_type_dependencies() [2/2]

◆ get_type_dependencies_i()

◆ get_type_info()

◆ get_type_object()

◆ get_type_object_i()

◆ get_type_objects()

◆ has_complete()

◆ OPENDDS_MAP() [1/4]

◆ OPENDDS_MAP() [2/4]

◆ OPENDDS_MAP() [3/4]

◆ OPENDDS_MAP() [4/4]

◆ OPENDDS_MAP_CMP()

◆ remove_guid_from_dynamic_map()

◆ set_type_object_defaults()

◆ type_identifier_to_dynamic()

◆ type_object_in_cache()

◆ update_type_identifier_map()

Member Data Documentation

◆ complete_to_minimal_ti_map_

◆ gt_map_

◆ mutex_

◆ to_empty_

◆ type_dependencies_map_

◆ type_info_empty_

◆ type_info_map_

◆ type_map_