typeobject_generator Class Reference

#include <typeobject_generator.h>

Inheritance diagram for typeobject_generator:

Collaboration diagram for typeobject_generator:

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, bool nested_key_only=false)
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 1700 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 1435 of file typeobject_generator.cpp.

References OpenDDS::XTypes::CompleteTypeObject::alias_type, OpenDDS::XTypes::MinimalTypeObject::alias_type, OpenDDS::XTypes::CompleteAliasType::body, OpenDDS::XTypes::MinimalAliasType::body, canonical_name(), OpenDDS::XTypes::CompleteAliasBody::common, OpenDDS::XTypes::MinimalAliasBody::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::CompleteAliasHeader::detail, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::CompleteAliasType::header, OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::TypeObject::minimal, OpenDDS::XTypes::CommonAliasBody::related_type, OpenDDS::XTypes::TK_ALIAS, and OpenDDS::XTypes::CompleteTypeDetail::type_name.

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 1266 of file typeobject_generator.cpp.

References OpenDDS::XTypes::Sequence< T >::append(), OpenDDS::XTypes::CompleteTypeObject::array_type, OpenDDS::XTypes::MinimalTypeObject::array_type, be_global, OpenDDS::XTypes::CommonArrayHeader::bound_seq, canonical_name(), OpenDDS::XTypes::CompleteCollectionElement::common, OpenDDS::XTypes::MinimalCollectionElement::common, OpenDDS::XTypes::CompleteArrayHeader::common, OpenDDS::XTypes::MinimalArrayHeader::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::CompleteArrayHeader::detail, OpenDDS::XTypes::EK_BOTH, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::CompleteArrayType::element, OpenDDS::XTypes::MinimalArrayType::element, OpenDDS::XTypes::CommonCollectionElement::element_flags, OpenDDS::XTypes::CompleteArrayType::header, OpenDDS::XTypes::MinimalArrayType::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::TI_PLAIN_ARRAY_LARGE, OpenDDS::XTypes::TI_PLAIN_ARRAY_SMALL, OpenDDS::XTypes::TK_ARRAY, OpenDDS::XTypes::CommonCollectionElement::type, and OpenDDS::XTypes::CompleteTypeDetail::type_name.

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 1208 of file typeobject_generator.cpp.

References OpenDDS::XTypes::Sequence< T >::append(), be_global, OpenDDS::XTypes::CommonEnumeratedHeader::bit_bound, canonical_name(), OpenDDS::XTypes::CompleteEnumeratedLiteral::common, OpenDDS::XTypes::MinimalEnumeratedLiteral::common, OpenDDS::XTypes::CompleteEnumeratedHeader::common, OpenDDS::XTypes::MinimalEnumeratedHeader::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::CompleteEnumeratedLiteral::detail, OpenDDS::XTypes::MinimalEnumeratedLiteral::detail, OpenDDS::XTypes::CompleteEnumeratedHeader::detail, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, OpenDDS::XTypes::CompleteEnumeratedType::enum_flags, OpenDDS::XTypes::MinimalEnumeratedType::enum_flags, OpenDDS::XTypes::CompleteTypeObject::enumerated_type, OpenDDS::XTypes::MinimalTypeObject::enumerated_type, extensibilitykind_appendable, extensibilitykind_mutable, OpenDDS::XTypes::CommonEnumeratedLiteral::flags, OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteEnumeratedType::header, OpenDDS::XTypes::MinimalEnumeratedType::header, OpenDDS::XTypes::IS_DEFAULT, OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::CompleteEnumeratedType::literal_seq, OpenDDS::XTypes::MinimalEnumeratedType::literal_seq, OpenDDS::XTypes::TypeObject::minimal, be_util::misc_error_and_abort(), name, OpenDDS::XTypes::CompleteMemberDetail::name, OpenDDS::XTypes::MinimalMemberDetail::name_hash, scope2vector(), OpenDDS::XTypes::Sequence< T >::sort(), OpenDDS::XTypes::TK_ENUM, OpenDDS::XTypes::CompleteTypeDetail::type_name, and OpenDDS::XTypes::CommonEnumeratedLiteral::value.

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 1453 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 1355 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.

References OpenDDS::XTypes::CompleteMemberDetail::ann_builtin, OpenDDS::XTypes::Sequence< T >::append(), autoidkind_hash, OpenDDS::XTypes::CompleteStructHeader::base_type, OpenDDS::XTypes::MinimalStructHeader::base_type, be_global, Fields::begin(), canonical_name(), OpenDDS::XTypes::CompleteStructMember::common, OpenDDS::XTypes::MinimalStructMember::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::CompleteStructMember::detail, OpenDDS::XTypes::MinimalStructMember::detail, OpenDDS::XTypes::CompleteStructHeader::detail, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, Fields::end(), OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteStructType::header, OpenDDS::XTypes::MinimalStructType::header, OpenDDS::XTypes::IS_AUTOID_HASH, OpenDDS::XTypes::IS_EXTERNAL, OpenDDS::XTypes::IS_KEY, OpenDDS::XTypes::IS_MUST_UNDERSTAND, OpenDDS::XTypes::IS_NESTED, OpenDDS::XTypes::IS_OPTIONAL, OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::CommonStructMember::member_flags, OpenDDS::XTypes::CommonStructMember::member_id, OpenDDS::XTypes::CompleteStructType::member_seq, OpenDDS::XTypes::MinimalStructType::member_seq, OpenDDS::XTypes::CommonStructMember::member_type_id, OpenDDS::XTypes::TypeObject::minimal, name, OpenDDS::XTypes::CompleteMemberDetail::name, OpenDDS::XTypes::MinimalMemberDetail::name_hash, OpenDDS::XTypes::Sequence< T >::sort(), OpenDDS::XTypes::CompleteStructType::struct_flags, OpenDDS::XTypes::MinimalStructType::struct_flags, OpenDDS::XTypes::CompleteTypeObject::struct_type, OpenDDS::XTypes::MinimalTypeObject::struct_type, OpenDDS::XTypes::TK_NONE, OpenDDS::XTypes::TK_STRUCTURE, and OpenDDS::XTypes::CompleteTypeDetail::type_name.

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);
  }

  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 1515 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 1112 of file typeobject_generator.cpp.

References OpenDDS::XTypes::CompleteMemberDetail::ann_builtin, OpenDDS::XTypes::Sequence< T >::append(), autoidkind_hash, be_global, Fields::begin(), canonical_name(), OpenDDS::XTypes::CompleteUnionMember::common, OpenDDS::XTypes::MinimalUnionMember::common, OpenDDS::XTypes::CompleteDiscriminatorMember::common, OpenDDS::XTypes::MinimalDiscriminatorMember::common, OpenDDS::XTypes::TypeObject::complete, OpenDDS::XTypes::CompleteUnionMember::detail, OpenDDS::XTypes::MinimalUnionMember::detail, OpenDDS::XTypes::CompleteUnionHeader::detail, OpenDDS::XTypes::CompleteUnionType::discriminator, OpenDDS::XTypes::MinimalUnionType::discriminator, OpenDDS::XTypes::EK_COMPLETE, OpenDDS::XTypes::EK_MINIMAL, Fields::end(), OpenDDS::XTypes::hash_member_name(), OpenDDS::XTypes::CompleteUnionType::header, OpenDDS::XTypes::IS_AUTOID_HASH, OpenDDS::XTypes::IS_DEFAULT, OpenDDS::XTypes::IS_EXTERNAL, OpenDDS::XTypes::IS_KEY, OpenDDS::XTypes::IS_NESTED, OpenDDS::XTypes::CompleteTypeObject::kind, OpenDDS::XTypes::MinimalTypeObject::kind, OpenDDS::XTypes::TypeObject::kind, OpenDDS::XTypes::CommonUnionMember::label_seq, OpenDDS::XTypes::CommonUnionMember::member_flags, OpenDDS::XTypes::CommonDiscriminatorMember::member_flags, OpenDDS::XTypes::CommonUnionMember::member_id, OpenDDS::XTypes::CompleteUnionType::member_seq, OpenDDS::XTypes::MinimalUnionType::member_seq, OpenDDS::XTypes::TypeObject::minimal, name, OpenDDS::XTypes::CompleteMemberDetail::name, OpenDDS::XTypes::MinimalMemberDetail::name_hash, OpenDDS::XTypes::Sequence< T >::sort(), OpenDDS::XTypes::TK_UNION, OpenDDS::XTypes::CommonUnionMember::type_id, OpenDDS::XTypes::CommonDiscriminatorMember::type_id, OpenDDS::XTypes::CompleteTypeDetail::type_name, OpenDDS::XTypes::CompleteUnionType::union_flags, OpenDDS::XTypes::MinimalUnionType::union_flags, OpenDDS::XTypes::CompleteTypeObject::union_type, and OpenDDS::XTypes::MinimalTypeObject::union_type.

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);
  }
  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 1673 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 1645 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:

• typeobject_generator.h
• typeobject_generator.cpp