#include <typeobject_generator.h>

Inheritance diagram for typeobject_generator:

Collaboration diagram for typeobject_generator:

[legend]

Classes
struct	Element

struct	TypeIdentifierPair

struct	TypeObjectPair

Public Member Functions
	typeobject_generator ()

void	gen_epilogue ()

bool	gen_enum (AST_Enum node, UTL_ScopedName name, const std::vector< AST_EnumVal > &contents, const char repoid)

bool	gen_struct (AST_Structure node, UTL_ScopedName name, const std::vector< AST_Field > &fields, AST_Type::SIZE_TYPE size, const char repoid)

bool	gen_typedef (AST_Typedef node, UTL_ScopedName name, AST_Type type, const char repoid)

bool	gen_union (AST_Union node, UTL_ScopedName name, const std::vector< AST_UnionBranch > &branches, AST_Type type, const char *repoid)

void	produce_output (bool flag)

void	produce_xtypes_complete (bool flag)

void	use_old_typeobject_encoding ()

Public Member Functions inherited from dds_generator
virtual	~dds_generator ()=0

virtual bool	do_included_files () const

virtual void	gen_prologue ()

virtual bool	gen_const (UTL_ScopedName , bool, AST_Constant )

virtual bool	gen_struct_fwd (UTL_ScopedName *, AST_Type::SIZE_TYPE)

virtual bool	gen_interf (AST_Interface , UTL_ScopedName , bool, const std::vector< AST_Interface > &, const std::vector< AST_Interface > &, const std::vector< AST_Attribute > &, const std::vector< AST_Operation > &, const char *)

virtual bool	gen_interf_fwd (UTL_ScopedName *)

virtual bool	gen_native (AST_Native , UTL_ScopedName , const char *)

virtual bool	gen_union_fwd (AST_UnionFwd , UTL_ScopedName , AST_Type::SIZE_TYPE)

Static Public Member Functions
static std::string	tag_type (UTL_ScopedName *name)

Static Public Member Functions inherited from dds_generator
static std::string	get_tag_name (const std::string &base_name, const std::string &qualifier="")

static std::string	get_xtag_name (UTL_ScopedName *name)

static bool	cxx_escaped (const std::string &s)

static std::string	valid_var_name (const std::string &str)

static std::string	to_string (Identifier *id, EscapeContext ec=EscapeContext_Normal)

static std::string	scoped_helper (UTL_ScopedName sn, const char sep, EscapeContext cxt=EscapeContext_Normal)

static std::string	module_scope_helper (UTL_ScopedName sn, const char sep, EscapeContext cxt=EscapeContext_Normal)

Private Types
typedef std::map< AST_Type *, TypeObjectPair >	TypeObjectMap

typedef std::map< AST_Type *, TypeIdentifierPair >	HashTypeIdentifierMap

typedef std::map< AST_Type *, OpenDDS::XTypes::TypeIdentifier >	FullyDescriptiveTypeIdentifierMap

typedef std::vector< AST_Type * >	Stack

Private Member Functions
void	consider (Element &v, AST_Type *type, const std::string &anonymous_name)

void	strong_connect (AST_Type *type, const std::string &anonymous_name)

void	generate_type_identifier (AST_Type *type, bool force_type_object)

void	generate_struct_type_identifier (AST_Type *type)

void	generate_union_type_identifier (AST_Type *type)

void	generate_enum_type_identifier (AST_Type *type)

void	generate_array_type_identifier (AST_Type *type, bool force_type_object)

void	generate_sequence_type_identifier (AST_Type *type, bool force_type_object)

void	generate_alias_type_identifier (AST_Type *type)

void	generate_primitive_type_identifier (AST_Type *type)

void	update_maps (AST_Type *type, const OpenDDS::XTypes::TypeObject &minimal_to, const OpenDDS::XTypes::TypeObject &complete_to)

void	set_builtin_member_annotations (AST_Decl *member, OpenDDS::XTypes::Optional< OpenDDS::XTypes::AppliedBuiltinMemberAnnotations > &annotations)

OpenDDS::XTypes::TypeIdentifier	get_minimal_type_identifier (AST_Type *type)

OpenDDS::XTypes::TypeIdentifier	get_complete_type_identifier (AST_Type *type)

bool	generate (AST_Type node, UTL_ScopedName name)

void	declare_get_type_map ()

Private Attributes
TypeObjectMap	type_object_map_

HashTypeIdentifierMap	hash_type_identifier_map_

FullyDescriptiveTypeIdentifierMap	fully_desc_type_identifier_map_

OpenDDS::XTypes::TypeMap	minimal_type_map_

OpenDDS::XTypes::TypeMap	complete_type_map_

bool	produce_output_

bool	produce_xtypes_complete_

size_t	index_

Stack	stack_

std::map< AST_Type *, Element >	element_

bool	get_type_map_declared_

OpenDDS::DCPS::Encoding *	typeid_encoding_

Detailed Description

Definition at line 14 of file typeobject_generator.h.

Member Typedef Documentation

◆ FullyDescriptiveTypeIdentifierMap

typedef std::map<AST_Type*, OpenDDS::XTypes::TypeIdentifier> typeobject_generator::FullyDescriptiveTypeIdentifierMap

private

Definition at line 109 of file typeobject_generator.h.

◆ HashTypeIdentifierMap

typedef std::map<AST_Type*, TypeIdentifierPair> typeobject_generator::HashTypeIdentifierMap

private

Definition at line 106 of file typeobject_generator.h.

◆ Stack

typedef std::vector<AST_Type*> typeobject_generator::Stack

private

Definition at line 118 of file typeobject_generator.h.

◆ TypeObjectMap

typedef std::map<AST_Type*, TypeObjectPair> typeobject_generator::TypeObjectMap

private

Definition at line 97 of file typeobject_generator.h.

Constructor & Destructor Documentation

◆ typeobject_generator()

typeobject_generator::typeobject_generator ( )

inline

Definition at line 16 of file typeobject_generator.h.

References gen_enum(), gen_epilogue(), gen_struct(), gen_typedef(), gen_union(), name, and tag_type().

     : produce_output_(false)
     , produce_xtypes_complete_(false)
     , index_(0)
     , get_type_map_declared_(false)
     , typeid_encoding_(0)
   {}

Member Function Documentation

◆ consider()

void typeobject_generator::consider	(	Element &	v,
		AST_Type *	type,
		const std::string &	anonymous_name
	)

private

Definition at line 715 of file typeobject_generator.cpp.

References typeobject_generator::Element::lowlink.

Referenced by typeobject_generator::Element::operator<().

 {
   switch (type->node_type()) {
   case AST_ConcreteType::NT_union_fwd:
     {
       AST_UnionFwd* const n = dynamic_cast<AST_UnionFwd*>(type);
       type = n->full_definition();
       break;
     }
   case AST_ConcreteType::NT_struct_fwd:
     {
       AST_StructureFwd* const n = dynamic_cast<AST_StructureFwd*>(type);
       type = n->full_definition();
       break;
     }
   default:
     break;
   }
 
   if (element_.find(type) == element_.end()) {
     strong_connect(type, anonymous_name);
     v.lowlink = std::min(v.lowlink, element_[type].lowlink);
   } else if (element_[type].on_stack) {
     v.lowlink = std::min(v.lowlink, element_[type].index);
   }
 }

◆ declare_get_type_map()

void typeobject_generator::declare_get_type_map ( )

private

Definition at line 548 of file typeobject_generator.cpp.

References be_global.

Referenced by typeobject_generator::Element::operator<().

 {
   if (!produce_output_ || get_type_map_declared_) {
     return;
   }
   get_type_map_declared_ = true;
 
   be_global->add_include("dds/DCPS/XTypes/TypeObject.h", BE_GlobalData::STREAM_H);
 
   be_global->impl_ << "static const XTypes::TypeMap& get_minimal_type_map();\n";
 
   if (produce_xtypes_complete_) {
     be_global->impl_ << "static const XTypes::TypeMap& get_complete_type_map();\n";
   }
 }

◆ gen_enum()

bool typeobject_generator::gen_enum	(	AST_Enum *	node,
		UTL_ScopedName *	name,
		const std::vector< AST_EnumVal *> &	contents,
		const char *	repoid
	)

virtual

Reimplemented from dds_generator.

Definition at line 686 of file typeobject_generator.cpp.

References java_ts_generator::generate().

Referenced by typeobject_generator().

 {
   return generate(node, name);
 }

◆ gen_epilogue()

void typeobject_generator::gen_epilogue ( )

virtual

Reimplemented from dds_generator.

Definition at line 573 of file typeobject_generator.cpp.

References be_global.

Referenced by typeobject_generator().

 {
   be_global->add_include("dds/DCPS/Service_Participant.h");
 
   if (!produce_output_ || !get_type_map_declared_) {
     return;
   }
 
   NamespaceGuard ng;
 
   be_global->impl_ <<
     "namespace {\n";
 
   size_t idx = 0;
   for (OpenDDS::XTypes::TypeMap::const_iterator pos = minimal_type_map_.begin();
        pos != minimal_type_map_.end(); ++pos, ++idx) {
     be_global->impl_ <<
       "XTypes::TypeObject minimal_to" << idx << "()\n"
       "{\n"
       "  const unsigned char to_bytes[] = { ";
     dump_bytes(pos->second);
     be_global->add_include("<stdexcept>", BE_GlobalData::STREAM_CPP);
     be_global->impl_ <<
       "  };\n"
       "  XTypes::TypeObject to;\n"
       "  if (!to_type_object(to_bytes, sizeof(to_bytes), to)) {\n"
       "    throw std::runtime_error(\"Could not deserialize minimal Type Object " << idx << "\");\n"
       "  }\n"
       "  return to;\n"
       "}\n\n";
   }
 
   be_global->impl_ <<
     "XTypes::TypeMap get_minimal_type_map_private()\n"
     "{\n"
     "  XTypes::TypeMap tm;\n";
 
   idx = 0;
   for (OpenDDS::XTypes::TypeMap::const_iterator pos = minimal_type_map_.begin();
        pos != minimal_type_map_.end(); ++pos, ++idx) {
     be_global->impl_ << "  tm[" << pos->first << "] = minimal_to" << idx << "();\n";
   }
 
   be_global->impl_ <<
     "  return tm;\n"
     "}\n\n";
 
   if (produce_xtypes_complete_) {
     idx = 0;
     for (OpenDDS::XTypes::TypeMap::const_iterator pos = complete_type_map_.begin();
          pos != complete_type_map_.end(); ++pos, ++idx) {
       be_global->impl_ <<
         "XTypes::TypeObject complete_to" << idx << "()\n"
         "{\n"
         "  const unsigned char to_bytes[] = {\n";
       dump_bytes(pos->second);
       be_global->add_include("<stdexcept>", BE_GlobalData::STREAM_CPP);
       be_global->impl_ <<
         "  };\n"
         "  XTypes::TypeObject to;\n"
         "  if (!to_type_object(to_bytes, sizeof(to_bytes), to)) {\n"
         "    throw std::runtime_error(\"Could not deserialize complete Type Object " << idx << "\");\n"
         "  }\n"
         "  return to;\n"
         "}\n\n";
     }
 
     be_global->impl_ <<
       "XTypes::TypeMap get_complete_type_map_private()\n"
       "{\n"
       "  XTypes::TypeMap tm;\n";
 
     idx = 0;
     for (OpenDDS::XTypes::TypeMap::const_iterator pos = complete_type_map_.begin();
          pos != complete_type_map_.end(); ++pos, ++idx) {
       be_global->impl_ << "  tm[" << pos->first << "] = complete_to" << idx << "();\n";
     }
 
     be_global->impl_ <<
       "  return tm;\n"
       "}\n";
   }
   be_global->impl_ << "}\n\n";
 
   const std::string common = "{\n"
     "  static XTypes::TypeMap tm;\n"
     "  ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, TheServiceParticipant->get_static_xtypes_lock(), tm);\n"
     "  if (tm.empty()) {\n";
 
   be_global->impl_ <<
     "const XTypes::TypeMap& get_minimal_type_map()\n" << common <<
     "    tm = get_minimal_type_map_private();\n"
     "  }\n"
     "  return tm;\n"
     "}\n\n";
 
   if (produce_xtypes_complete_) {
     be_global->impl_ <<
       "const XTypes::TypeMap& get_complete_type_map()\n" << common <<
       "    tm = get_complete_type_map_private();\n"
       "  }\n"
       "  return tm;\n"
       "}\n";
   }
 }

◆ gen_struct()

bool typeobject_generator::gen_struct	(	AST_Structure *	node,
		UTL_ScopedName *	name,
		const std::vector< AST_Field *> &	fields,
		AST_Type::SIZE_TYPE	size,
		const char *	repoid
	)

virtual

Implements dds_generator.

Definition at line 693 of file typeobject_generator.cpp.

References java_ts_generator::generate().

Referenced by typeobject_generator().

 {
   return generate(node, name);
 }

◆ gen_typedef()

bool typeobject_generator::gen_typedef	(	AST_Typedef *	node,
		UTL_ScopedName *	name,
		AST_Type *	type,
		const char *	repoid
	)

virtual

Implements dds_generator.

Definition at line 700 of file typeobject_generator.cpp.

References java_ts_generator::generate().

Referenced by typeobject_generator().

 {
   return generate(node, name);
 }

◆ gen_union()

bool typeobject_generator::gen_union	(	AST_Union *	node,
		UTL_ScopedName *	name,
		const std::vector< AST_UnionBranch *> &	branches,
		AST_Type *	type,
		const char *	repoid
	)

virtual

Implements dds_generator.

Definition at line 707 of file typeobject_generator.cpp.

References java_ts_generator::generate().

Referenced by typeobject_generator().

 {
   return generate(node, name);
 }

◆ generate()

bool typeobject_generator::generate	(	AST_Type *	node,
		UTL_ScopedName *	name
	)

private

Definition at line 1705 of file typeobject_generator.cpp.

References be_global, and Function::endArgs().

Referenced by typeobject_generator::Element::operator<().

 {
   strong_connect(node, "");
 
   if (!produce_output_) {
     return true;
   }
 
   NamespaceGuard ng;
   const string clazz = tag_type(name);
 
   be_global->header_ << "struct " << clazz << " {};\n";
 
   const std::string common = "  static XTypes::TypeIdentifier ti;\n"
     "  ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, TheServiceParticipant->get_static_xtypes_lock(), ti);\n"
     "  if (ti.kind() == XTypes::TK_NONE) {\n";
 
   {
     const string decl = "getMinimalTypeIdentifier<" + clazz + ">";
     Function gti(decl.c_str(), "const XTypes::TypeIdentifier&", "");
     gti.endArgs();
     const OpenDDS::XTypes::TypeIdentifier ti = get_minimal_type_identifier(node);
     be_global->impl_ << common <<
       "    ti = " << ti << ";\n"
       "  }\n"
       "  return ti;\n";
   }
 
   declare_get_type_map();
   {
     const string decl = "getMinimalTypeMap<" + clazz + ">";
     Function gti(decl.c_str(), "const XTypes::TypeMap&", "");
     gti.endArgs();
     be_global->impl_ <<
       "  return get_minimal_type_map();\n";
   }
 
   if (produce_xtypes_complete_) {
     {
       const string decl = "getCompleteTypeIdentifier<" + clazz + ">";
       Function gti(decl.c_str(), "const XTypes::TypeIdentifier&", "");
       gti.endArgs();
 
       if (produce_xtypes_complete_) {
         const OpenDDS::XTypes::TypeIdentifier ti = get_complete_type_identifier(node);
         be_global->impl_ << common <<
           "    ti = " << ti << ";\n"
           "  }\n"
           "  return ti;\n";
       } else {
         be_global->impl_ <<
           "  static XTypes::TypeIdentifier ti;\n"
           "  return ti;\n";
       }
     }
 
     {
       const string decl = "getCompleteTypeMap<" + clazz + ">";
       Function gti(decl.c_str(), "const XTypes::TypeMap&", "");
       gti.endArgs();
       be_global->impl_ <<
         "  return get_complete_type_map();\n";
     }
   }
 
   return true;
 }

◆ generate_alias_type_identifier()

void typeobject_generator::generate_alias_type_identifier ( AST_Type * type )

private

Definition at line 1440 of file typeobject_generator.cpp.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Typedef* const n = dynamic_cast<AST_Typedef*>(type);
 
   OpenDDS::XTypes::TypeObject minimal_to, complete_to;
   minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
   minimal_to.minimal.kind = OpenDDS::XTypes::TK_ALIAS;
   minimal_to.minimal.alias_type.body.common.related_type = get_minimal_type_identifier(n->base_type());
 
   complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
   complete_to.complete.kind = OpenDDS::XTypes::TK_ALIAS;
   complete_to.complete.alias_type.header.detail.type_name = canonical_name(type->name());
   complete_to.complete.alias_type.body.common.related_type = get_complete_type_identifier(n->base_type());
 
   update_maps(type, minimal_to, complete_to);
 }

◆ generate_array_type_identifier()

void typeobject_generator::generate_array_type_identifier	(	AST_Type *	type,
		bool	force_type_object
	)

private

Definition at line 1271 of file typeobject_generator.cpp.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Array* const n = dynamic_cast<AST_Array*>(type);
 
   const TryConstructFailAction trycon = be_global->try_construct(n->base_type());
   OpenDDS::XTypes::CollectionElementFlag cef = try_construct_to_member_flag(trycon);
   if (be_global->is_external(n->base_type())) {
     cef |= OpenDDS::XTypes::IS_EXTERNAL;
   }
   const OpenDDS::XTypes::TypeIdentifier minimal_elem_ti = get_minimal_type_identifier(n->base_type());
   const OpenDDS::XTypes::TypeIdentifier complete_elem_ti = get_complete_type_identifier(n->base_type());
 
   if (be_global->is_plain(type) && !force_type_object) {
     const OpenDDS::XTypes::EquivalenceKind minimal_ek =
       OpenDDS::XTypes::is_fully_descriptive(minimal_elem_ti) ? OpenDDS::XTypes::EK_BOTH : OpenDDS::XTypes::EK_MINIMAL;
     const OpenDDS::XTypes::EquivalenceKind complete_ek =
       minimal_ek == OpenDDS::XTypes::EK_BOTH ? minimal_ek : OpenDDS::XTypes::EK_COMPLETE;
 
     ACE_CDR::ULong max_bound = 0;
     for (ACE_CDR::ULong dim = 0; dim != n->n_dims(); ++dim) {
       max_bound = std::max(max_bound, n->dims()[dim]->ev()->u.ulval);
     }
 
     if (max_bound < 256) {
       OpenDDS::XTypes::TypeIdentifier minimal_ti(OpenDDS::XTypes::TI_PLAIN_ARRAY_SMALL);
       minimal_ti.array_sdefn().header.equiv_kind = minimal_ek;
       minimal_ti.array_sdefn().header.element_flags = cef;
       for (ACE_CDR::ULong dim = 0; dim != n->n_dims(); ++dim) {
         minimal_ti.array_sdefn().array_bound_seq.append(n->dims()[dim]->ev()->u.ulval);
       }
       minimal_ti.array_sdefn().element_identifier = minimal_elem_ti;
 
       if (minimal_ek == OpenDDS::XTypes::EK_BOTH) {
         fully_desc_type_identifier_map_[type] = minimal_ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier complete_ti(OpenDDS::XTypes::TI_PLAIN_ARRAY_SMALL);
         complete_ti.array_sdefn().header.equiv_kind = complete_ek;
         complete_ti.array_sdefn().header.element_flags = cef;
         complete_ti.array_sdefn().array_bound_seq = minimal_ti.array_sdefn().array_bound_seq;
         complete_ti.array_sdefn().element_identifier = complete_elem_ti;
 
         const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
         hash_type_identifier_map_[type] = ti_pair;
       }
     } else {
       OpenDDS::XTypes::TypeIdentifier minimal_ti(OpenDDS::XTypes::TI_PLAIN_ARRAY_LARGE);
       minimal_ti.array_ldefn().header.equiv_kind = minimal_ek;
       minimal_ti.array_ldefn().header.element_flags = cef;
       for (ACE_CDR::ULong dim = 0; dim != n->n_dims(); ++dim) {
         minimal_ti.array_ldefn().array_bound_seq.append(n->dims()[dim]->ev()->u.ulval);
       }
       minimal_ti.array_ldefn().element_identifier = minimal_elem_ti;
 
       if (minimal_ek == OpenDDS::XTypes::EK_BOTH) {
         fully_desc_type_identifier_map_[type] = minimal_ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier complete_ti(OpenDDS::XTypes::TI_PLAIN_ARRAY_LARGE);
         complete_ti.array_ldefn().header.equiv_kind = complete_ek;
         complete_ti.array_ldefn().header.element_flags = cef;
         complete_ti.array_ldefn().array_bound_seq = minimal_ti.array_ldefn().array_bound_seq;
         complete_ti.array_ldefn().element_identifier = complete_elem_ti;
 
         const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
         hash_type_identifier_map_[type] = ti_pair;
       }
     }
   } else {
     OpenDDS::XTypes::TypeObject minimal_to, complete_to;
     minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
     minimal_to.minimal.kind = OpenDDS::XTypes::TK_ARRAY;
     for (ACE_CDR::ULong dim = 0; dim != n->n_dims(); ++dim) {
       minimal_to.minimal.array_type.header.common.bound_seq.append(n->dims()[dim]->ev()->u.ulval);
     }
     minimal_to.minimal.array_type.element.common.element_flags = cef;
     minimal_to.minimal.array_type.element.common.type = minimal_elem_ti;
 
     complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
     complete_to.complete.kind = OpenDDS::XTypes::TK_ARRAY;
     complete_to.complete.array_type.header.common.bound_seq = minimal_to.minimal.array_type.header.common.bound_seq;
     complete_to.complete.array_type.header.detail.type_name = canonical_name(type->name());
 
     complete_to.complete.array_type.element.common.element_flags = cef;
     complete_to.complete.array_type.element.common.type = complete_elem_ti;
 
     update_maps(type, minimal_to, complete_to);
   }
 }

◆ generate_enum_type_identifier()

void typeobject_generator::generate_enum_type_identifier ( AST_Type * type )

private

Definition at line 1213 of file typeobject_generator.cpp.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Enum* const n = dynamic_cast<AST_Enum*>(type);
   std::vector<AST_EnumVal*> contents;
   scope2vector(contents, n, AST_Decl::NT_enum_val);
   bool has_extensibility_annotation = false;
   const ExtensibilityKind ek = be_global->extensibility(type, extensibilitykind_appendable, has_extensibility_annotation);
 
   if (ek == extensibilitykind_mutable) {
     be_util::misc_error_and_abort("MUTABLE extensibility for enum is not allowed", type);
   }
 
   size_t default_literal_idx = 0;
   for (size_t i = 0; i != contents.size(); ++i) {
     if (contents[i]->annotations().find("@default_literal")) {
       default_literal_idx = i;
       break;
     }
   }
 
   OpenDDS::XTypes::TypeObject minimal_to, complete_to;
   minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
   minimal_to.minimal.kind = OpenDDS::XTypes::TK_ENUM;
   if (has_extensibility_annotation || !be_global->default_enum_extensibility_zero()) {
     minimal_to.minimal.enumerated_type.enum_flags = extensibility_to_type_flag(ek);
   }
   // TODO: Add support for @bit_bound.
   minimal_to.minimal.enumerated_type.header.common.bit_bound = 32;
 
   complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
   complete_to.complete.kind = OpenDDS::XTypes::TK_ENUM;
   if (has_extensibility_annotation || !be_global->default_enum_extensibility_zero()) {
     complete_to.complete.enumerated_type.enum_flags = extensibility_to_type_flag(ek);
   }
   complete_to.complete.enumerated_type.header.common.bit_bound = 32;
   complete_to.complete.enumerated_type.header.detail.type_name = canonical_name(type->name());
 
   for (size_t i = 0; i != contents.size(); ++i) {
     OpenDDS::XTypes::MinimalEnumeratedLiteral minimal_lit;
     minimal_lit.common.value = contents[i]->constant_value()->ev()->u.eval;
     minimal_lit.common.flags = (i == default_literal_idx ? OpenDDS::XTypes::IS_DEFAULT : 0);
     const std::string name = canonical_name(contents[i]->local_name());
     OpenDDS::XTypes::hash_member_name(minimal_lit.detail.name_hash, name);
     minimal_to.minimal.enumerated_type.literal_seq.append(minimal_lit);
 
     OpenDDS::XTypes::CompleteEnumeratedLiteral complete_lit;
     complete_lit.common = minimal_lit.common;
     complete_lit.detail.name = name;
 
     complete_to.complete.enumerated_type.literal_seq.append(complete_lit);
   }
   minimal_to.minimal.enumerated_type.literal_seq.sort();
   complete_to.complete.enumerated_type.literal_seq.sort();
 
   update_maps(type, minimal_to, complete_to);
 }

◆ generate_primitive_type_identifier()

void typeobject_generator::generate_primitive_type_identifier ( AST_Type * type )

private

Definition at line 1458 of file typeobject_generator.cpp.

References be_util::misc_error_and_abort(), OpenDDS::XTypes::TK_BOOLEAN, OpenDDS::XTypes::TK_BYTE, OpenDDS::XTypes::TK_CHAR16, OpenDDS::XTypes::TK_CHAR8, OpenDDS::XTypes::TK_FLOAT128, OpenDDS::XTypes::TK_FLOAT32, OpenDDS::XTypes::TK_FLOAT64, 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 typeobject_generator::Element::operator<().

 {
   AST_PredefinedType* const n = dynamic_cast<AST_PredefinedType*>(type);
   switch (n->pt()) {
   case AST_PredefinedType::PT_long:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_INT32);
     break;
   case AST_PredefinedType::PT_ulong:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_UINT32);
     break;
   case AST_PredefinedType::PT_longlong:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_INT64);
     break;
   case AST_PredefinedType::PT_ulonglong:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_UINT64);
     break;
   case AST_PredefinedType::PT_short:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_INT16);
     break;
   case AST_PredefinedType::PT_ushort:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_UINT16);
     break;
 #if OPENDDS_HAS_EXPLICIT_INTS
   case AST_PredefinedType::PT_int8:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_INT8);
     break;
   case AST_PredefinedType::PT_uint8:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_UINT8);
     break;
 #endif
   case AST_PredefinedType::PT_float:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_FLOAT32);
     break;
   case AST_PredefinedType::PT_double:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_FLOAT64);
     break;
   case AST_PredefinedType::PT_longdouble:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_FLOAT128);
     break;
   case AST_PredefinedType::PT_char:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_CHAR8);
     break;
   case AST_PredefinedType::PT_wchar:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_CHAR16);
     break;
   case AST_PredefinedType::PT_boolean:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_BOOLEAN);
     break;
   case AST_PredefinedType::PT_octet:
     fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_BYTE);
     break;
   case AST_PredefinedType::PT_any:
   case AST_PredefinedType::PT_object:
   case AST_PredefinedType::PT_value:
   case AST_PredefinedType::PT_abstract:
   case AST_PredefinedType::PT_void:
   case AST_PredefinedType::PT_pseudo:
     be_util::misc_error_and_abort("Unexpected primitive type");
   }
 }

◆ generate_sequence_type_identifier()

void typeobject_generator::generate_sequence_type_identifier	(	AST_Type *	type,
		bool	force_type_object
	)

private

Definition at line 1360 of file typeobject_generator.cpp.

References be_global, OpenDDS::XTypes::CommonCollectionHeader::bound, OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::XTypes::CompleteCollectionHeader::common, OpenDDS::XTypes::MinimalCollectionHeader::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::EK_BOTH, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::CompleteSequenceType::element, OpenDDS::XTypes::MinimalSequenceType::element, OpenDDS::XTypes::CommonCollectionElement::element_flags, OpenDDS::XTypes::CompleteSequenceType::header, OpenDDS::XTypes::MinimalSequenceType::header, OpenDDS::XTypes::IS_EXTERNAL, OpenDDS::XTypes::is_fully_descriptive(), OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::TypeObject::minimal, OpenDDS::XTypes::CompleteTypeObject::sequence_type, OpenDDS::XTypes::MinimalTypeObject::sequence_type, OpenDDS::XTypes::TI_PLAIN_SEQUENCE_LARGE, OpenDDS::XTypes::TI_PLAIN_SEQUENCE_SMALL, OpenDDS::XTypes::TK_SEQUENCE, and OpenDDS::XTypes::CommonCollectionElement::type.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Sequence* const n = dynamic_cast<AST_Sequence*>(type);
 
   ACE_CDR::ULong bound = 0;
   if (!n->unbounded()) {
     bound = n->max_size()->ev()->u.ulval;
   }
 
   const TryConstructFailAction trycon = be_global->try_construct(n->base_type());
   OpenDDS::XTypes::CollectionElementFlag cef = try_construct_to_member_flag(trycon);
   if (be_global->is_external(n->base_type())) {
     cef |= OpenDDS::XTypes::IS_EXTERNAL;
   }
   const OpenDDS::XTypes::TypeIdentifier minimal_elem_ti = get_minimal_type_identifier(n->base_type());
   const OpenDDS::XTypes::TypeIdentifier complete_elem_ti = get_complete_type_identifier(n->base_type());
 
   if (be_global->is_plain(type) && !force_type_object) {
     const OpenDDS::XTypes::EquivalenceKind minimal_ek =
       OpenDDS::XTypes::is_fully_descriptive(minimal_elem_ti) ? OpenDDS::XTypes::EK_BOTH : OpenDDS::XTypes::EK_MINIMAL;
     const OpenDDS::XTypes::EquivalenceKind complete_ek =
       minimal_ek == OpenDDS::XTypes::EK_BOTH ? minimal_ek : OpenDDS::XTypes::EK_COMPLETE;
     if (bound < 256) {
       OpenDDS::XTypes::TypeIdentifier minimal_ti(OpenDDS::XTypes::TI_PLAIN_SEQUENCE_SMALL);
       minimal_ti.seq_sdefn().header.equiv_kind = minimal_ek;
       minimal_ti.seq_sdefn().header.element_flags = cef;
       minimal_ti.seq_sdefn().bound = bound;
       minimal_ti.seq_sdefn().element_identifier = minimal_elem_ti;
 
       if (minimal_ek == OpenDDS::XTypes::EK_BOTH) {
         fully_desc_type_identifier_map_[type] = minimal_ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier complete_ti(OpenDDS::XTypes::TI_PLAIN_SEQUENCE_SMALL);
         complete_ti.seq_sdefn().header.equiv_kind = complete_ek;
         complete_ti.seq_sdefn().header.element_flags = cef;
         complete_ti.seq_sdefn().bound = bound;
         complete_ti.seq_sdefn().element_identifier = complete_elem_ti;
 
         const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
         hash_type_identifier_map_[type] = ti_pair;
       }
     } else {
       OpenDDS::XTypes::TypeIdentifier minimal_ti(OpenDDS::XTypes::TI_PLAIN_SEQUENCE_LARGE);
       minimal_ti.seq_ldefn().header.equiv_kind = minimal_ek;
       minimal_ti.seq_ldefn().header.element_flags = cef;
       minimal_ti.seq_ldefn().bound = bound;
       minimal_ti.seq_ldefn().element_identifier = minimal_elem_ti;
 
       if (minimal_ek == OpenDDS::XTypes::EK_BOTH) {
         fully_desc_type_identifier_map_[type] = minimal_ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier complete_ti(OpenDDS::XTypes::TI_PLAIN_SEQUENCE_LARGE);
         complete_ti.seq_ldefn().header.equiv_kind = complete_ek;
         complete_ti.seq_ldefn().header.element_flags = cef;
         complete_ti.seq_ldefn().bound = bound;
         complete_ti.seq_ldefn().element_identifier = complete_elem_ti;
 
         const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
         hash_type_identifier_map_[type] = ti_pair;
       }
     }
   } else {
     OpenDDS::XTypes::TypeObject minimal_to, complete_to;
     minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
     minimal_to.minimal.kind = OpenDDS::XTypes::TK_SEQUENCE;
     minimal_to.minimal.sequence_type.header.common.bound = bound;
     minimal_to.minimal.sequence_type.element.common.element_flags = cef;
     minimal_to.minimal.sequence_type.element.common.type = minimal_elem_ti;
 
     complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
     complete_to.complete.kind = OpenDDS::XTypes::TK_SEQUENCE;
     complete_to.complete.sequence_type.header.common.bound = bound;
     complete_to.complete.sequence_type.element.common.element_flags = cef;
     complete_to.complete.sequence_type.element.common.type = complete_elem_ti;
 
     update_maps(type, minimal_to, complete_to);
   }
 }

◆ generate_struct_type_identifier()

void typeobject_generator::generate_struct_type_identifier ( AST_Type * type )

private

Definition at line 1032 of file typeobject_generator.cpp.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Structure* const n = dynamic_cast<AST_Structure*>(type);
   const Fields fields(n);
 
   const ExtensibilityKind exten = be_global->extensibility(n);
   const AutoidKind auto_id = be_global->autoid(n);
 
   OpenDDS::XTypes::TypeObject minimal_to, complete_to;
   minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
   minimal_to.minimal.kind = OpenDDS::XTypes::TK_STRUCTURE;
 
   minimal_to.minimal.struct_type.struct_flags = extensibility_to_type_flag(exten);
 
   if (be_global->is_nested(n)) {
     minimal_to.minimal.struct_type.struct_flags |= OpenDDS::XTypes::IS_NESTED;
   }
 
   if (auto_id == autoidkind_hash) {
     minimal_to.minimal.struct_type.struct_flags |= OpenDDS::XTypes::IS_AUTOID_HASH;
   }
 
   // TODO: Support inheritance.
   minimal_to.minimal.struct_type.header.base_type = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_NONE);
 
   complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
   complete_to.complete.kind = OpenDDS::XTypes::TK_STRUCTURE;
 
   complete_to.complete.struct_type.struct_flags = minimal_to.minimal.struct_type.struct_flags;
   complete_to.complete.struct_type.header.base_type = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_NONE);
   complete_to.complete.struct_type.header.detail.type_name = canonical_name(type->name());
   // @verbatim and custom annotations are not supported.
 
   for (Fields::Iterator i = fields.begin(); i != fields.end(); ++i) {
     AST_Field* field = *i;
     const TryConstructFailAction trycon = be_global->try_construct(field);
 
     OpenDDS::XTypes::MinimalStructMember minimal_member;
     minimal_member.common.member_id = be_global->get_id(field);
     minimal_member.common.member_flags = try_construct_to_member_flag(trycon);
 
     if (be_global->is_optional(field)) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_OPTIONAL;
     }
 
     if (be_global->is_must_understand(field)) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_MUST_UNDERSTAND;
     }
 
     if (be_global->is_key(field)) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_KEY;
     }
 
     if (be_global->is_external(field)) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_EXTERNAL;
     }
 
     minimal_member.common.member_type_id = get_minimal_type_identifier(field->field_type());
     const std::string name = canonical_name(field->local_name());
     OpenDDS::XTypes::hash_member_name(minimal_member.detail.name_hash, name);
     minimal_to.minimal.struct_type.member_seq.append(minimal_member);
 
     OpenDDS::XTypes::CompleteStructMember complete_member;
     complete_member.common.member_id = minimal_member.common.member_id;
     complete_member.common.member_flags = minimal_member.common.member_flags;
     complete_member.common.member_type_id = get_complete_type_identifier(field->field_type());
 
     complete_member.detail.name = name;
     set_builtin_member_annotations(field, complete_member.detail.ann_builtin);
 
     complete_to.complete.struct_type.member_seq.append(complete_member);
   }
 
   if (be_global->old_typeobject_member_order()) {
     minimal_to.minimal.struct_type.member_seq.sort();
     complete_to.complete.struct_type.member_seq.sort();
   }
 
   update_maps(type, minimal_to, complete_to);
 }

◆ generate_type_identifier()

void typeobject_generator::generate_type_identifier	(	AST_Type *	type,
		bool	force_type_object
	)

private

Definition at line 1520 of file typeobject_generator.cpp.

References be_util::misc_error_and_abort(), OpenDDS::XTypes::TI_STRING16_LARGE, OpenDDS::XTypes::TI_STRING16_SMALL, OpenDDS::XTypes::TI_STRING8_LARGE, OpenDDS::XTypes::TI_STRING8_SMALL, and OpenDDS::XTypes::TK_NONE.

Referenced by typeobject_generator::Element::operator<().

 {
   // Generate both minimal and complete identifiers (and type objects) and cache.
   switch (type->node_type()) {
 
   case AST_ConcreteType::NT_union:
     {
       generate_union_type_identifier(type);
       break;
     }
 
   case AST_ConcreteType::NT_struct:
     {
       generate_struct_type_identifier(type);
       break;
     }
 
   case AST_ConcreteType::NT_enum:
     {
       generate_enum_type_identifier(type);
       break;
     }
 
   case AST_ConcreteType::NT_string:
     {
       AST_String* const n = dynamic_cast<AST_String*>(type);
       ACE_CDR::ULong bound = n->max_size()->ev()->u.ulval;
       if (bound < 256) {
         OpenDDS::XTypes::TypeIdentifier ti(OpenDDS::XTypes::TI_STRING8_SMALL);
         ti.string_sdefn().bound = bound;
         fully_desc_type_identifier_map_[type] = ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier ti(OpenDDS::XTypes::TI_STRING8_LARGE);
         ti.string_ldefn().bound = bound;
         fully_desc_type_identifier_map_[type] = ti;
       }
       break;
     }
 
   case AST_ConcreteType::NT_wstring:
     {
       AST_String* const n = dynamic_cast<AST_String*>(type);
       ACE_CDR::ULong bound = n->max_size()->ev()->u.ulval;
       if (bound < 256) {
         OpenDDS::XTypes::TypeIdentifier ti(OpenDDS::XTypes::TI_STRING16_SMALL);
         ti.string_sdefn().bound = bound;
         fully_desc_type_identifier_map_[type] = ti;
       } else {
         OpenDDS::XTypes::TypeIdentifier ti(OpenDDS::XTypes::TI_STRING16_LARGE);
         ti.string_ldefn().bound = bound;
         fully_desc_type_identifier_map_[type] = ti;
       }
       break;
     }
 
   case AST_ConcreteType::NT_array:
     {
       generate_array_type_identifier(type, force_type_object);
       break;
     }
 
   case AST_ConcreteType::NT_sequence:
     {
       generate_sequence_type_identifier(type, force_type_object);
       break;
     }
 
   case AST_ConcreteType::NT_typedef:
     {
       generate_alias_type_identifier(type);
       break;
     }
 
   case AST_ConcreteType::NT_pre_defined:
     {
       generate_primitive_type_identifier(type);
       break;
     }
 
   case AST_ConcreteType::NT_fixed:
   case AST_ConcreteType::NT_interface:
   case AST_ConcreteType::NT_interface_fwd:
     {
       fully_desc_type_identifier_map_[type] = OpenDDS::XTypes::TypeIdentifier(OpenDDS::XTypes::TK_NONE);
       break;
     }
 
   case AST_ConcreteType::NT_struct_fwd:
   case AST_ConcreteType::NT_union_fwd:
   case AST_ConcreteType::NT_native:
   case AST_ConcreteType::NT_factory:
   case AST_ConcreteType::NT_finder:
   case AST_ConcreteType::NT_component:
   case AST_ConcreteType::NT_component_fwd:
   case AST_ConcreteType::NT_home:
   case AST_ConcreteType::NT_eventtype:
   case AST_ConcreteType::NT_eventtype_fwd:
   case AST_ConcreteType::NT_valuebox:
   case AST_ConcreteType::NT_type:
   case AST_ConcreteType::NT_porttype:
   case AST_ConcreteType::NT_provides:
   case AST_ConcreteType::NT_uses:
   case AST_ConcreteType::NT_publishes:
   case AST_ConcreteType::NT_emits:
   case AST_ConcreteType::NT_consumes:
   case AST_ConcreteType::NT_ext_port:
   case AST_ConcreteType::NT_mirror_port:
   case AST_ConcreteType::NT_connector:
   case AST_ConcreteType::NT_param_holder:
   case AST_ConcreteType::NT_annotation_decl:
   case AST_ConcreteType::NT_annotation_appl:
   case AST_ConcreteType::NT_annotation_member:
   case AST_ConcreteType::NT_module:
   case AST_ConcreteType::NT_root:
   case AST_ConcreteType::NT_valuetype:
   case AST_ConcreteType::NT_valuetype_fwd:
   case AST_ConcreteType::NT_const:
   case AST_ConcreteType::NT_except:
   case AST_ConcreteType::NT_attr:
   case AST_ConcreteType::NT_op:
   case AST_ConcreteType::NT_argument:
   case AST_ConcreteType::NT_union_branch:
   case AST_ConcreteType::NT_field:
   case AST_ConcreteType::NT_enum_val:
     be_util::misc_error_and_abort("Unexpected AST type", type);
   }
 }

◆ generate_union_type_identifier()

void typeobject_generator::generate_union_type_identifier ( AST_Type * type )

private

Definition at line 1114 of file typeobject_generator.cpp.

Referenced by typeobject_generator::Element::operator<().

 {
   AST_Union* const n = dynamic_cast<AST_Union*>(type);
   AST_Type* discriminator = n->disc_type();
   const Fields fields(n);
 
   const ExtensibilityKind exten = be_global->extensibility(n);
   const AutoidKind auto_id = be_global->autoid(n);
 
   OpenDDS::XTypes::TypeObject minimal_to, complete_to;
   minimal_to.kind = OpenDDS::XTypes::EK_MINIMAL;
   minimal_to.minimal.kind = OpenDDS::XTypes::TK_UNION;
   minimal_to.minimal.union_type.union_flags = extensibility_to_type_flag(exten);
 
   if (be_global->is_nested(n)) {
     minimal_to.minimal.union_type.union_flags |= OpenDDS::XTypes::IS_NESTED;
   }
 
   if (auto_id == autoidkind_hash) {
     minimal_to.minimal.union_type.union_flags |= OpenDDS::XTypes::IS_AUTOID_HASH;
   }
 
   const TryConstructFailAction trycon = be_global->union_discriminator_try_construct(n);
   minimal_to.minimal.union_type.discriminator.common.member_flags = try_construct_to_member_flag(trycon);
   if (be_global->union_discriminator_is_key(n)) {
     minimal_to.minimal.union_type.discriminator.common.member_flags |= OpenDDS::XTypes::IS_KEY;
   }
   minimal_to.minimal.union_type.discriminator.common.type_id = get_minimal_type_identifier(discriminator);
 
   complete_to.kind = OpenDDS::XTypes::EK_COMPLETE;
   complete_to.complete.kind = OpenDDS::XTypes::TK_UNION;
   complete_to.complete.union_type.union_flags = minimal_to.minimal.union_type.union_flags;
 
   complete_to.complete.union_type.header.detail.type_name = canonical_name(type->name());
 
   complete_to.complete.union_type.discriminator.common.member_flags =
     minimal_to.minimal.union_type.discriminator.common.member_flags;
   complete_to.complete.union_type.discriminator.common.type_id = get_complete_type_identifier(discriminator);
 
   for (Fields::Iterator i = fields.begin(); i != fields.end(); ++i) {
     AST_UnionBranch* branch = dynamic_cast<AST_UnionBranch*>(*i);
     const TryConstructFailAction trycon = be_global->try_construct(branch);
 
     bool is_default = false;
     for (unsigned long j = 0; j < branch->label_list_length(); ++j) {
       AST_UnionLabel* label = branch->label(j);
       if (label->label_kind() == AST_UnionLabel::UL_default) {
         is_default = true;
         break;
       }
     }
 
     OpenDDS::XTypes::MinimalUnionMember minimal_member;
     minimal_member.common.member_id = be_global->get_id(branch);
     minimal_member.common.member_flags = try_construct_to_member_flag(trycon);
 
     if (is_default) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_DEFAULT;
     }
 
     if (be_global->is_external(branch)) {
       minimal_member.common.member_flags |= OpenDDS::XTypes::IS_EXTERNAL;
     }
 
     minimal_member.common.type_id = get_minimal_type_identifier(branch->field_type());
 
     for (unsigned long j = 0; j < branch->label_list_length(); ++j) {
       AST_UnionLabel* label = branch->label(j);
       if (label->label_kind() != AST_UnionLabel::UL_default) {
         minimal_member.common.label_seq.append(to_long(*label->label_val()->ev()));
       }
     }
     minimal_member.common.label_seq.sort();
 
     const std::string name = canonical_name(branch->local_name());
     OpenDDS::XTypes::hash_member_name(minimal_member.detail.name_hash, name);
     minimal_to.minimal.union_type.member_seq.append(minimal_member);
 
     OpenDDS::XTypes::CompleteUnionMember complete_member;
     complete_member.common.member_id = minimal_member.common.member_id;
     complete_member.common.member_flags = minimal_member.common.member_flags;
     complete_member.common.type_id = get_complete_type_identifier(branch->field_type());
     complete_member.common.label_seq = minimal_member.common.label_seq;
 
     complete_member.detail.name = name;
     set_builtin_member_annotations(branch, complete_member.detail.ann_builtin);
 
     complete_to.complete.union_type.member_seq.append(complete_member);
   }
 
   if (be_global->old_typeobject_member_order()) {
     minimal_to.minimal.union_type.member_seq.sort();
     complete_to.complete.union_type.member_seq.sort();
   }
 
   update_maps(type, minimal_to, complete_to);
 }

◆ get_complete_type_identifier()

OpenDDS::XTypes::TypeIdentifier typeobject_generator::get_complete_type_identifier ( AST_Type * type )

private

Definition at line 1678 of file typeobject_generator.cpp.

References OPENDDS_ASSERT.

Referenced by typeobject_generator::Element::operator<().

 {
   switch(type->node_type()) {
   case AST_Decl::NT_union_fwd:
     {
       AST_UnionFwd* const td = dynamic_cast<AST_UnionFwd*>(type);
       return get_complete_type_identifier(td->full_definition());
     }
   case AST_Decl::NT_struct_fwd:
     {
       AST_StructureFwd* const td = dynamic_cast<AST_StructureFwd*>(type);
       return get_complete_type_identifier(td->full_definition());
     }
   default:
     break;
   }
 
   if (fully_desc_type_identifier_map_.count(type) != 0) {
     return fully_desc_type_identifier_map_[type];
   }
 
   HashTypeIdentifierMap::const_iterator pos = hash_type_identifier_map_.find(type);
   OPENDDS_ASSERT(pos != hash_type_identifier_map_.end());
   return pos->second.complete;
 }

◆ get_minimal_type_identifier()

OpenDDS::XTypes::TypeIdentifier typeobject_generator::get_minimal_type_identifier ( AST_Type * type )

private

Definition at line 1650 of file typeobject_generator.cpp.

References OPENDDS_ASSERT.

Referenced by typeobject_generator::Element::operator<().

 {
   switch(type->node_type()) {
   case AST_Decl::NT_union_fwd:
     {
       AST_UnionFwd* const td = dynamic_cast<AST_UnionFwd*>(type);
       return get_minimal_type_identifier(td->full_definition());
     }
   case AST_Decl::NT_struct_fwd:
     {
       AST_StructureFwd* const td = dynamic_cast<AST_StructureFwd*>(type);
       return get_minimal_type_identifier(td->full_definition());
     }
   default:
     break;
   }
 
   if (fully_desc_type_identifier_map_.count(type) != 0) {
     return fully_desc_type_identifier_map_[type];
   }
 
   HashTypeIdentifierMap::const_iterator pos = hash_type_identifier_map_.find(type);
   OPENDDS_ASSERT(pos != hash_type_identifier_map_.end());
   return pos->second.minimal;
 }

◆ produce_output()

void typeobject_generator::produce_output ( bool flag )

inline

Definition at line 41 of file typeobject_generator.h.

References produce_output_.

   {
     produce_output_ = flag;
   }

◆ produce_xtypes_complete()

void typeobject_generator::produce_xtypes_complete ( bool flag )

inline

Definition at line 46 of file typeobject_generator.h.

References produce_xtypes_complete_, and use_old_typeobject_encoding().

   {
     produce_xtypes_complete_ = flag;
   }

◆ set_builtin_member_annotations()

void typeobject_generator::set_builtin_member_annotations	(	AST_Decl *	member,
		OpenDDS::XTypes::Optional< OpenDDS::XTypes::AppliedBuiltinMemberAnnotations > &	annotations
	)

private

Definition at line 1015 of file typeobject_generator.cpp.

References be_global, OpenDDS::XTypes::AppliedBuiltinMemberAnnotations::hash_id, AnnotationWithValue< T >::node_value_exists(), value, and OpenDDS::XTypes::Optional< T >::value().

Referenced by typeobject_generator::Element::operator<().

 {
   // Support only @hashid annotation for member at this time.
   const HashidAnnotation* hashid_ann = dynamic_cast<const HashidAnnotation*>(be_global->builtin_annotations_["::@hashid"]);
   std::string hash_name;
   if (hashid_ann->node_value_exists(member, hash_name)) {
     OpenDDS::XTypes::Optional<std::string> hash_id(hash_name);
     if (!annotations) {
       OpenDDS::XTypes::AppliedBuiltinMemberAnnotations value;
       annotations = OpenDDS::XTypes::Optional<OpenDDS::XTypes::AppliedBuiltinMemberAnnotations>(value);
     }
     annotations.value().hash_id = hash_id;
   }
 }

◆ strong_connect()

void typeobject_generator::strong_connect	(	AST_Type *	type,
		const std::string &	anonymous_name
	)

private

Definition at line 743 of file typeobject_generator.cpp.

References OpenDDS::XTypes::Sequence< T >::append(), be_global, Fields::begin(), canonical_name(), OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::STUN::encoding(), Fields::end(), OpenDDS::XTypes::get_typeobject_encoding(), typeobject_generator::Element::index, OpenDDS::XTypes::TypeIdentifier::kind(), ACE_Message_Block::length(), typeobject_generator::Element::lowlink, OpenDDS::DCPS::MD5Hash(), be_util::misc_error_and_abort(), typeobject_generator::Element::name, typeobject_generator::Element::on_stack, OPENDDS_ASSERT, ACE_Message_Block::rd_ptr(), OpenDDS::DCPS::serialized_size(), OpenDDS::XTypes::TI_STRONGLY_CONNECTED_COMPONENT, OpenDDS::DCPS::to_dds_string(), and typeobject_generator::Element::type.

Referenced by typeobject_generator::Element::operator<().

 {
   switch (type->node_type()) {
   case AST_ConcreteType::NT_union_fwd:
     {
       AST_UnionFwd* const n = dynamic_cast<AST_UnionFwd*>(type);
       type = n->full_definition();
       break;
     }
   case AST_ConcreteType::NT_struct_fwd:
     {
       AST_StructureFwd* const n = dynamic_cast<AST_StructureFwd*>(type);
       type = n->full_definition();
       break;
     }
   default:
     break;
   }
 
   Element& v = element_[type];
   v.type = type;
   v.index = index_;
   v.lowlink = index_;
   ++index_;
   stack_.push_back(type);
   v.on_stack = true;
 
   using OpenDDS::XTypes::MemberId;
   AST_Structure* const stru = dynamic_cast<AST_Structure*>(type);
   switch (type->node_type()) {
 
   case AST_ConcreteType::NT_union:
     {
       AST_Union* const n = dynamic_cast<AST_Union*>(type);
       v.name = canonical_name(n->name());
 
       AST_Type* discriminator = n->disc_type();
       const Fields fields(n);
 
       consider(v, discriminator, v.name + ".d");
 
       const AutoidKind auto_id = be_global->autoid(n);
       MemberId member_id = 0;
 
       for (Fields::Iterator i = fields.begin(); i != fields.end(); ++i) {
         AST_UnionBranch* ub = dynamic_cast<AST_UnionBranch*>(*i);
         const MemberId id = be_global->compute_id(stru, ub, auto_id, member_id);
         consider(v, ub->field_type(), v.name + "." + OpenDDS::DCPS::to_dds_string(id));
       }
 
       break;
     }
 
   case AST_ConcreteType::NT_struct:
     {
       AST_Structure* const n = dynamic_cast<AST_Structure*>(type);
       v.name = canonical_name(n->name());
 
       // TODO: Struct inheritance.
 
       const Fields fields(n);
       const AutoidKind auto_id = be_global->autoid(n);
       MemberId member_id = 0;
 
       for (Fields::Iterator i = fields.begin(); i != fields.end(); ++i) {
         AST_Field* field = *i;
         const MemberId id = be_global->compute_id(stru, field, auto_id, member_id);
         consider(v, field->field_type(), v.name + "." + OpenDDS::DCPS::to_dds_string(id));
       }
 
       break;
     }
 
   case AST_ConcreteType::NT_array:
     {
       AST_Array* const n = dynamic_cast<AST_Array*>(type);
       v.name = anonymous_name + ".a";
       consider(v, n->base_type(), v.name);
       break;
     }
 
   case AST_ConcreteType::NT_sequence:
     {
       AST_Sequence* const n = dynamic_cast<AST_Sequence*>(type);
       v.name = anonymous_name + ".s";
       consider(v, n->base_type(), v.name);
       break;
     }
 
   case AST_ConcreteType::NT_typedef:
     {
       AST_Typedef* const n = dynamic_cast<AST_Typedef*>(type);
       v.name = canonical_name(n->name());
       // TODO: What is the member name for an anonymous type in a typedef?
       // 7.3.4.9.2
       consider(v, n->base_type(), v.name + ".0");
       break;
     }
 
   case AST_ConcreteType::NT_enum:
     {
       AST_Enum* const n = dynamic_cast<AST_Enum*>(type);
       v.name = canonical_name(n->name());
       break;
     }
 
   case AST_ConcreteType::NT_string:
   case AST_ConcreteType::NT_wstring:
   case AST_ConcreteType::NT_pre_defined:
   case AST_ConcreteType::NT_fixed:
   case AST_ConcreteType::NT_interface:
   case AST_ConcreteType::NT_interface_fwd:
       break;
 
   case AST_ConcreteType::NT_struct_fwd:
   case AST_ConcreteType::NT_union_fwd:
   case AST_ConcreteType::NT_native:
   case AST_ConcreteType::NT_factory:
   case AST_ConcreteType::NT_finder:
   case AST_ConcreteType::NT_component:
   case AST_ConcreteType::NT_component_fwd:
   case AST_ConcreteType::NT_home:
   case AST_ConcreteType::NT_eventtype:
   case AST_ConcreteType::NT_eventtype_fwd:
   case AST_ConcreteType::NT_valuebox:
   case AST_ConcreteType::NT_type:
   case AST_ConcreteType::NT_porttype:
   case AST_ConcreteType::NT_provides:
   case AST_ConcreteType::NT_uses:
   case AST_ConcreteType::NT_publishes:
   case AST_ConcreteType::NT_emits:
   case AST_ConcreteType::NT_consumes:
   case AST_ConcreteType::NT_ext_port:
   case AST_ConcreteType::NT_mirror_port:
   case AST_ConcreteType::NT_connector:
   case AST_ConcreteType::NT_param_holder:
   case AST_ConcreteType::NT_annotation_decl:
   case AST_ConcreteType::NT_annotation_appl:
   case AST_ConcreteType::NT_annotation_member:
   case AST_ConcreteType::NT_module:
   case AST_ConcreteType::NT_root:
   case AST_ConcreteType::NT_valuetype:
   case AST_ConcreteType::NT_valuetype_fwd:
   case AST_ConcreteType::NT_const:
   case AST_ConcreteType::NT_except:
   case AST_ConcreteType::NT_attr:
   case AST_ConcreteType::NT_op:
   case AST_ConcreteType::NT_argument:
   case AST_ConcreteType::NT_union_branch:
   case AST_ConcreteType::NT_field:
   case AST_ConcreteType::NT_enum_val:
     be_util::misc_error_and_abort("Unexpected AST type", type);
     break;
   }
 
   if (v.lowlink == v.index) {
     typedef std::vector<Element> List;
     List scc;
     AST_Type* wt;
     do {
       wt = stack_.back();
       stack_.pop_back();
       Element& w = element_[wt];
       w.on_stack = false;
       scc.push_back(w);
     } while (wt != v.type);
 
     // Sort types in SCC using lexicographic order of their fully qualified names.
     std::sort(scc.begin(), scc.end());
 
     if (scc.size() == 1) {
       generate_type_identifier(scc[0].type, false);
     } else {
       // Compute temporary type identifiers for the types in SCC with hash value of zero.
       OpenDDS::XTypes::TypeIdentifier minimal_ti(OpenDDS::XTypes::TI_STRONGLY_CONNECTED_COMPONENT);
       minimal_ti.sc_component_id().sc_component_id.kind = OpenDDS::XTypes::EK_MINIMAL;
       std::memset(&minimal_ti.sc_component_id().sc_component_id.hash, 0, sizeof(OpenDDS::XTypes::EquivalenceHash));
       minimal_ti.sc_component_id().scc_length = static_cast<int>(scc.size());
 
       OpenDDS::XTypes::TypeIdentifier complete_ti = minimal_ti;
       complete_ti.sc_component_id().sc_component_id.kind = OpenDDS::XTypes::EK_COMPLETE;
 
       {
         size_t idx = 0;
         for (List::const_iterator pos = scc.begin(); pos != scc.end(); ++pos) {
           minimal_ti.sc_component_id().scc_index = static_cast<int>(++idx); // Starts at 1.
           complete_ti.sc_component_id().scc_index = minimal_ti.sc_component_id().scc_index;
           const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
           hash_type_identifier_map_[pos->type] = ti_pair;
         }
       }
 
       // Construct temporary type objects from the temporary type identifiers.
       OpenDDS::XTypes::TypeObjectSeq minimal_seq, complete_seq;
       for (List::const_iterator pos = scc.begin(); pos != scc.end(); ++pos) {
         generate_type_identifier(pos->type, true);
         OPENDDS_ASSERT(type_object_map_.count(pos->type) != 0);
         minimal_seq.append(type_object_map_[pos->type].minimal);
         complete_seq.append(type_object_map_[pos->type].complete);
       }
 
       // Compute the final type identifiers with the correct hash value.
       const OpenDDS::DCPS::Encoding& encoding = OpenDDS::XTypes::get_typeobject_encoding();
       size_t minimal_size = serialized_size(encoding, minimal_seq);
       ACE_Message_Block minimal_buff(minimal_size);
       OpenDDS::DCPS::Serializer minimal_ser(&minimal_buff, encoding);
       if (!(minimal_ser << minimal_seq)) {
         be_util::misc_error_and_abort("Failed to serialize minimal type object sequence in strongly-connected component", type);
       }
 
       unsigned char result[sizeof(OpenDDS::DCPS::MD5Result)];
       OpenDDS::DCPS::MD5Hash(result, minimal_buff.rd_ptr(), minimal_buff.length());
 
       // First 14 bytes of MD5 of the serialized TypeObject using XCDR
       // version 2 with Little Endian encoding
       std::memcpy(minimal_ti.sc_component_id().sc_component_id.hash, result, sizeof(OpenDDS::XTypes::EquivalenceHash));
 
       size_t complete_size = serialized_size(encoding, complete_seq);
       ACE_Message_Block complete_buff(complete_size);
       OpenDDS::DCPS::Serializer complete_ser(&complete_buff, encoding);
       if (!(complete_ser << complete_seq)) {
         be_util::misc_error_and_abort("Failed to serialize complete type object sequence in strongly-connected component", type);
       }
 
       OpenDDS::DCPS::MD5Hash(result, complete_buff.rd_ptr(), complete_buff.length());
       std::memcpy(complete_ti.sc_component_id().sc_component_id.hash, result, sizeof(OpenDDS::XTypes::EquivalenceHash));
 
       {
         size_t idx = 0;
         for (List::const_iterator pos = scc.begin(); pos != scc.end(); ++pos) {
           minimal_ti.sc_component_id().scc_index = static_cast<int>(++idx);
           complete_ti.sc_component_id().scc_index = minimal_ti.sc_component_id().scc_index;
           const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
           hash_type_identifier_map_[pos->type] = ti_pair;
         }
       }
 
       // Compute the final type objects with the final type identifiers.
       for (List::const_iterator pos = scc.begin(); pos != scc.end(); ++pos) {
         generate_type_identifier(pos->type, true);
         const OpenDDS::XTypes::TypeIdentifier& minimal_ti = hash_type_identifier_map_[pos->type].minimal;
         const OpenDDS::XTypes::TypeIdentifier& complete_ti = hash_type_identifier_map_[pos->type].complete;
         minimal_type_map_[minimal_ti] = type_object_map_[pos->type].minimal;
         complete_type_map_[complete_ti] = type_object_map_[pos->type].complete;
       }
     }
   }
 }

◆ tag_type()

string typeobject_generator::tag_type ( UTL_ScopedName * name )

static

Definition at line 680 of file typeobject_generator.cpp.

References dds_generator::get_xtag_name().

Referenced by typeobject_generator().

 {
   return dds_generator::get_xtag_name(name);
 }

◆ update_maps()

void typeobject_generator::update_maps	(	AST_Type *	type,
		const OpenDDS::XTypes::TypeObject &	minimal_to,
		const OpenDDS::XTypes::TypeObject &	complete_to
	)

private

Definition at line 993 of file typeobject_generator.cpp.

References OpenDDS::XTypes::makeTypeIdentifier().

Referenced by typeobject_generator::Element::operator<().

 {
   const TypeObjectPair to_pair = {minimal_to, complete_to};
   type_object_map_[type] = to_pair;
 
   // In case of SCC, type identifiers of the types in SCC are computed first and
   // type objects are constructed using them. In that case, we don't want to update
   // each individual type's type identifier by hashing the corresponding type object.
   // On the other hand, type identifier is computed if the type is not part of a SCC.
   if (hash_type_identifier_map_.count(type) == 0) {
     const OpenDDS::XTypes::TypeIdentifier minimal_ti = makeTypeIdentifier(minimal_to, typeid_encoding_);
     const OpenDDS::XTypes::TypeIdentifier complete_ti = makeTypeIdentifier(complete_to, typeid_encoding_);
     const TypeIdentifierPair ti_pair = {minimal_ti, complete_ti};
     hash_type_identifier_map_[type] = ti_pair;
 
     minimal_type_map_[minimal_ti] = minimal_to;
     complete_type_map_[complete_ti] = complete_to;
   }
 }

◆ use_old_typeobject_encoding()

void typeobject_generator::use_old_typeobject_encoding ( )

Definition at line 565 of file typeobject_generator.cpp.

References OpenDDS::XTypes::get_typeobject_encoding(), and OpenDDS::DCPS::Encoding::skip_sequence_dheader().

Referenced by produce_xtypes_complete().

 {
   static OpenDDS::DCPS::Encoding enc = OpenDDS::XTypes::get_typeobject_encoding();
   enc.skip_sequence_dheader(true);
   typeid_encoding_ = &enc;
 }

Member Data Documentation

◆ complete_type_map_

OpenDDS::XTypes::TypeMap typeobject_generator::complete_type_map_

private

Definition at line 113 of file typeobject_generator.h.

◆ element_

std::map<AST_Type*, Element> typeobject_generator::element_

private

Definition at line 120 of file typeobject_generator.h.

◆ fully_desc_type_identifier_map_

FullyDescriptiveTypeIdentifierMap typeobject_generator::fully_desc_type_identifier_map_

private

Definition at line 110 of file typeobject_generator.h.

◆ get_type_map_declared_

bool typeobject_generator::get_type_map_declared_

private

Definition at line 121 of file typeobject_generator.h.

◆ hash_type_identifier_map_

HashTypeIdentifierMap typeobject_generator::hash_type_identifier_map_

private

Definition at line 107 of file typeobject_generator.h.

◆ index_

size_t typeobject_generator::index_

private

Definition at line 117 of file typeobject_generator.h.

◆ minimal_type_map_

OpenDDS::XTypes::TypeMap typeobject_generator::minimal_type_map_

private

Definition at line 112 of file typeobject_generator.h.

◆ produce_output_

bool typeobject_generator::produce_output_

private

Definition at line 115 of file typeobject_generator.h.

Referenced by produce_output().

◆ produce_xtypes_complete_

bool typeobject_generator::produce_xtypes_complete_

private

Definition at line 116 of file typeobject_generator.h.

Referenced by produce_xtypes_complete().

◆ stack_

Stack typeobject_generator::stack_

private

Definition at line 119 of file typeobject_generator.h.

◆ type_object_map_

TypeObjectMap typeobject_generator::type_object_map_

private

Definition at line 98 of file typeobject_generator.h.

◆ typeid_encoding_

OpenDDS::DCPS::Encoding* typeobject_generator::typeid_encoding_

private

Definition at line 122 of file typeobject_generator.h.

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

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FullyDescriptiveTypeIdentifierMap

◆ HashTypeIdentifierMap

◆ Stack

◆ TypeObjectMap

Constructor & Destructor Documentation

◆ typeobject_generator()

Member Function Documentation

◆ consider()

◆ declare_get_type_map()

◆ gen_enum()

◆ gen_epilogue()

◆ gen_struct()

◆ gen_typedef()

◆ gen_union()

◆ generate()

◆ generate_alias_type_identifier()

◆ generate_array_type_identifier()

◆ generate_enum_type_identifier()

◆ generate_primitive_type_identifier()

◆ generate_sequence_type_identifier()

◆ generate_struct_type_identifier()

◆ generate_type_identifier()

◆ generate_union_type_identifier()

◆ get_complete_type_identifier()

◆ get_minimal_type_identifier()

◆ produce_output()

◆ produce_xtypes_complete()

◆ set_builtin_member_annotations()

◆ strong_connect()

◆ tag_type()

◆ update_maps()

◆ use_old_typeobject_encoding()

Member Data Documentation

◆ complete_type_map_

◆ element_

◆ fully_desc_type_identifier_map_

◆ get_type_map_declared_

◆ hash_type_identifier_map_

◆ index_

◆ minimal_type_map_

◆ produce_output_

◆ produce_xtypes_complete_

◆ stack_

◆ type_object_map_

◆ typeid_encoding_