ts_generator Class Reference

#include <ts_generator.h>

Inheritance diagram for ts_generator:

Collaboration diagram for ts_generator:

Public Member Functions
	ts_generator ()
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 *, UTL_ScopedName *, AST_Type *, const char *)
bool	gen_union (AST_Union *node, UTL_ScopedName *name, const std::vector< AST_UnionBranch *> &, AST_Type *, const char *)
Public Member Functions inherited from dds_generator
virtual	~dds_generator ()=0
virtual bool	do_included_files () const
virtual void	gen_prologue ()
virtual void	gen_epilogue ()
virtual bool	gen_const (UTL_ScopedName *, bool, AST_Constant *)
virtual bool	gen_enum (AST_Enum *, UTL_ScopedName *, const std::vector< AST_EnumVal *> &, const char *)
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)

Private Member Functions
bool	generate_ts (AST_Decl *node, UTL_ScopedName *name)

Private Attributes
std::string	idl_template_

Additional Inherited Members
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)

Detailed Description

Definition at line 23 of file ts_generator.h.

Constructor & Destructor Documentation

ts_generator()

ts_generator::ts_generator

(

)

Definition at line 63 of file ts_generator.cpp.

References ACE_TEXT_ALWAYS_CHAR, be_global, TopicKeys::begin(), and TopicKeys::end().

  : idl_template_(read_template("IDL"))
{
}

Member Function Documentation

gen_struct()

bool ts_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 493 of file ts_generator.cpp.

References generate_ts().

{
  return generate_ts(node, name);
}

gen_typedef()

bool ts_generator::gen_typedef ( AST_Typedef *  , UTL_ScopedName *  , AST_Type *  , const char *    )

inlinevirtual

Implements dds_generator.

Definition at line 31 of file ts_generator.h.

  { return true; }

gen_union()

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

virtual

Implements dds_generator.

Definition at line 499 of file ts_generator.cpp.

References generate_ts().

{
  return generate_ts(node, name);
}

generate_ts()

bool ts_generator::generate_ts ( AST_Decl *  node, UTL_ScopedName *  name  )

private

Definition at line 94 of file ts_generator.cpp.

References be_global, ACE_String_Base< char >::c_str(), TopicKeys::count(), EscapeContext_ForGenIdl, EscapeContext_FromGenIdl, EscapeContext_StripEscapes, face_ts_generator::generate(), dds_generator::get_xtag_name(), idl_template_, OpenDDS::XTypes::key_count(), ACE_String_Base< char >::length(), scoped(), dds_generator::scoped_helper(), and dds_generator::to_string().

Referenced by gen_struct(), and gen_union().

{
  if (idl_template_.empty()) {
    // error reported in read_template
    return false;
  }
  if (!node || !name) {
    return false;
  }

  AST_Structure* struct_node = 0;
  AST_Union* union_node = 0;
  AST_Type::SIZE_TYPE size_type;
  if (node->node_type() == AST_Decl::NT_struct) {
    struct_node = dynamic_cast<AST_Structure*>(node);
    size_type = struct_node->size_type();
  } else if (node->node_type() == AST_Decl::NT_union) {
    union_node = dynamic_cast<AST_Union*>(node);
    size_type = union_node->size_type();
  } else {
    idl_global->err()->misc_error(
      "Could not cast AST Nodes to valid types", node);
    return false;
  }

  size_t key_count = 0;
  IDL_GlobalData::DCPS_Data_Type_Info* info = 0;
  TopicKeys keys;
  if (struct_node) {
    info = idl_global->is_dcps_type(name);
    if (be_global->is_topic_type(struct_node)) {
      keys = TopicKeys(struct_node);
      key_count = keys.count();
    } else if (info) {
      key_count = info->key_list_.size();
    } else {
      return true;
    }
  } else if (be_global->is_topic_type(union_node)) {
    key_count = be_global->union_discriminator_is_key(union_node) ? 1 : 0;
  } else {
    return true;
  }

  const std::string cxx_name = scoped(name);
  const std::string short_name = name->last_component()->get_string();
  const std::string ts_name = scoped(name, EscapeContext_FromGenIdl);
  const std::string ts_short_name = to_string(
    name->last_component(), EscapeContext_FromGenIdl);
  const std::string unescaped_name =
    dds_generator::scoped_helper(name, "::", EscapeContext_StripEscapes);
  const std::string name_underscores = dds_generator::scoped_helper(name, "_");
  static const std::string ns("OpenDDS::DCPS::");
  const std::string xtag = ns + get_xtag_name(name);

  static const char* idl_includes[] = {
    "dds/DdsDcpsInfrastructure.idl", "dds/DdsDcpsTopic.idl",
    "dds/DdsDcpsPublication.idl", "dds/DdsDcpsSubscriptionExt.idl",
    "dds/DdsDcpsTypeSupportExt.idl"
  };
  add_includes(idl_includes, BE_GlobalData::STREAM_IDL);

  std::string dc = be_global->header_name_.c_str();
  dc.replace(dc.end() - 6, dc.end() - 2, "C"); // s/Impl.h$/C.h/
  be_global->add_include(dc.c_str());

  static const char* h_includes[] = {
    "dds/DCPS/TypeSupportImpl.h", "dds/DCPS/ValueDispatcher.h"
  };
  add_includes(h_includes, BE_GlobalData::STREAM_H);

  static const char* cpp_includes[] = {
    "dds/DCPS/debug.h", "dds/DCPS/Registered_Data_Types.h",
    "dds/DdsDcpsDomainC.h", "dds/DCPS/Service_Participant.h",
    "dds/DCPS/Qos_Helper.h", "dds/DCPS/PublicationInstance.h",
    "dds/DCPS/PublisherImpl.h", "dds/DCPS/SubscriberImpl.h",
    "dds/DCPS/ReceivedDataElementList.h", "dds/DCPS/RakeResults_T.h",
    "dds/DCPS/BuiltInTopicUtils.h", "dds/DCPS/Util.h",
    "dds/DCPS/ContentFilteredTopicImpl.h", "dds/DCPS/RakeData.h",
    "dds/DCPS/MultiTopicDataReader_T.h", "dds/DCPS/DataWriterImpl_T.h",
    "dds/DCPS/DataReaderImpl_T.h", "dds/DCPS/XTypes/TypeObject.h"
  };
  add_includes(cpp_includes, BE_GlobalData::STREAM_CPP);

  std::map<std::string, std::string> replacements;
  replacements["SCOPED"] = scoped(name, EscapeContext_ForGenIdl);
  // SCOPED_NOT_GLOBAL is EscapeContext_FromGenIdl, because
  // DCPS_DATA_SEQUENCE_TYPE is strange.
  replacements["SCOPED_NOT_GLOBAL"] =
    dds_generator::scoped_helper(name, "::", EscapeContext_FromGenIdl);
  replacements["TYPE"] = to_string(name->last_component(), EscapeContext_ForGenIdl);
  replacements["EXPORT"] = be_global->export_macro().c_str();
  replacements["SEQ"] = be_global->sequence_suffix().c_str();

  ScopedNamespaceGuard idlGuard(name, be_global->idl_, "module");
  std::string idl = idl_template_;
  replaceAll(idl, replacements);
  be_global->idl_ << idl;

  be_global->header_ << be_global->versioning_begin() << "\n";
  {
    ScopedNamespaceGuard hGuard(name, be_global->header_);

    be_global->header_ <<
      "class " << ts_short_name << "TypeSupportImpl;\n";
  }
  be_global->header_ << be_global->versioning_end() << "\n";

  be_global->header_ <<
    "OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL\n"
    "namespace OpenDDS {\n"
    "namespace DCPS {\n"
    "template <>\n"
    "struct DDSTraits<" << cxx_name << "> {\n"
    "  typedef " << cxx_name << " MessageType;\n"
    "  typedef " << ts_name << be_global->sequence_suffix() << " MessageSequenceType;\n"
    "  typedef " << ts_name << be_global->sequence_suffix() << "::PrivateMemberAccess MessageSequenceAdapterType;\n"
    "  typedef " << ts_name << "TypeSupport TypeSupportType;\n"
    "  typedef " << ts_name << "TypeSupportImpl TypeSupportImplType;\n"
    "  typedef " << ts_name << "DataWriter DataWriterType;\n"
    "  typedef " << ts_name << "DataReader DataReaderType;\n"
    "  typedef " << cxx_name << "_OpenDDS_KeyLessThan LessThanType;\n"
    "  typedef OpenDDS::DCPS::KeyOnly<const " << cxx_name << "> KeyOnlyType;\n"
    "  typedef " << xtag << " XtagType;\n"
    "\n"
    "  static const char* type_name() { return \"" << unescaped_name << "\"; }\n"
    "  static size_t key_count() { return " << key_count << "; }\n"
    "  static bool is_key(const char*);\n"
    "};\n"
    "} // namespace DCPS\n"
    "} // namespace OpenDDS\n"
    "OPENDDS_END_VERSIONED_NAMESPACE_DECL\n\n";

  be_global->impl_ <<
    "OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL\n"
    "namespace OpenDDS {\n"
    "namespace DCPS {\n"
    "bool DDSTraits<" << cxx_name << ">::is_key(const char* field)\n"
    "{\n"
    "  ACE_UNUSED_ARG(field);\n";
  if (struct_node && key_count) {
    if (info) {
      gen_isDcpsKey(info);
    } else {
      gen_isDcpsKey(keys);
    }
  }
  be_global->impl_ <<
    "  return false;\n"
    "}\n"
    "} // namespace DCPS\n"
    "} // namespace OpenDDS\n"
    "OPENDDS_END_VERSIONED_NAMESPACE_DECL\n\n";

  be_global->header_ << be_global->versioning_begin() << "\n";
  {
    ScopedNamespaceGuard hGuard(name, be_global->header_);

    be_global->header_ <<
      "class " << be_global->export_macro() << " " << ts_short_name << "TypeSupportImpl\n"
      "  : public virtual OpenDDS::DCPS::LocalObject<" << ts_short_name << "TypeSupport>\n"
      "  , public virtual OpenDDS::DCPS::TypeSupportImpl_T<" << short_name << ">\n"
      "  , public virtual OpenDDS::DCPS::ValueDispatcher_T<" << short_name << ">\n"
      "{\n"
      "public:\n"
      "  typedef " << ts_short_name << "TypeSupport TypeSupportType;\n"
      "  typedef " << ts_short_name << "TypeSupport::_var_type _var_type;\n"
      "  typedef " << ts_short_name << "TypeSupport::_ptr_type _ptr_type;\n"
      "\n"
      "  " << ts_short_name << "TypeSupportImpl() {}\n"
      "  virtual ~" << ts_short_name << "TypeSupportImpl() {}\n"
      "\n"
      "  virtual " << be_global->versioning_name() << "::DDS::DataWriter_ptr create_datawriter();\n"
      "  virtual " << be_global->versioning_name() << "::DDS::DataReader_ptr create_datareader();\n"
      "#ifndef OPENDDS_NO_MULTI_TOPIC\n"
      "  virtual " << be_global->versioning_name() << "::DDS::DataReader_ptr create_multitopic_datareader();\n"
      "#endif /* !OPENDDS_NO_MULTI_TOPIC */\n"
      "#ifndef OPENDDS_NO_CONTENT_SUBSCRIPTION_PROFILE\n"
      "  virtual const OpenDDS::DCPS::MetaStruct& getMetaStructForType() const;\n"
      "#endif /* !OPENDDS_NO_CONTENT_SUBSCRIPTION_PROFILE */\n"
      "\n"
      "  virtual const OpenDDS::XTypes::TypeIdentifier& getMinimalTypeIdentifier() const;\n"
      "  virtual const OpenDDS::XTypes::TypeMap& getMinimalTypeMap() const;\n"
      "\n"
      "  virtual const OpenDDS::XTypes::TypeIdentifier& getCompleteTypeIdentifier() const;\n"
      "  virtual const OpenDDS::XTypes::TypeMap& getCompleteTypeMap() const;\n"
      "\n"
      "  ::DDS::ReturnCode_t encode_to_string(const " << short_name << "& in, CORBA::String_out out, OpenDDS::DCPS::RepresentationFormat* format);\n"
      "  ::DDS::ReturnCode_t encode_to_bytes(const " << short_name << "& in, ::DDS::OctetSeq_out out, OpenDDS::DCPS::RepresentationFormat* format);\n"
      "  ::DDS::ReturnCode_t decode_from_string(const char* in, " << short_name << "_out out, OpenDDS::DCPS::RepresentationFormat* format);\n"
      "  ::DDS::ReturnCode_t decode_from_bytes(const ::DDS::OctetSeq& in, " << short_name << "_out out, OpenDDS::DCPS::RepresentationFormat* format);\n"
      "\n"
      "  static " << ts_short_name << "TypeSupport::_ptr_type _narrow(CORBA::Object_ptr obj);\n"
      "};\n\n";
  }
  be_global->header_ << be_global->versioning_end() << "\n";

  be_global->impl_ << be_global->versioning_begin() << "\n";
  {
    ScopedNamespaceGuard cppGuard(name, be_global->impl_);
    be_global->impl_ <<
      "::DDS::DataWriter_ptr " << ts_short_name << "TypeSupportImpl::create_datawriter()\n"
      "{\n"
      "  typedef OpenDDS::DCPS::DataWriterImpl_T<" << short_name << "> DataWriterImplType;\n"
      "  ::DDS::DataWriter_ptr writer_impl = ::DDS::DataWriter::_nil();\n"
      "  ACE_NEW_NORETURN(writer_impl,\n"
      "                   DataWriterImplType());\n"
      "  return writer_impl;\n"
      "}\n\n"
      "::DDS::DataReader_ptr " << ts_short_name << "TypeSupportImpl::create_datareader()\n"
      "{\n"
      "  typedef OpenDDS::DCPS::DataReaderImpl_T<" << short_name << "> DataReaderImplType;\n"
      "  ::DDS::DataReader_ptr reader_impl = ::DDS::DataReader::_nil();\n"
      "  ACE_NEW_NORETURN(reader_impl,\n"
      "                   DataReaderImplType());\n"
      "  return reader_impl;\n"
      "}\n\n"
      "#ifndef OPENDDS_NO_MULTI_TOPIC\n"
      "::DDS::DataReader_ptr " << ts_short_name << "TypeSupportImpl::create_multitopic_datareader()\n"
      "{\n"
      "  typedef OpenDDS::DCPS::DataReaderImpl_T<" << short_name << "> DataReaderImplType;\n"
      "  typedef OpenDDS::DCPS::MultiTopicDataReader_T<" << short_name << ", DataReaderImplType> MultiTopicDataReaderImplType;\n"
      "  ::DDS::DataReader_ptr multitopic_reader_impl = ::DDS::DataReader::_nil();\n"
      "  ACE_NEW_NORETURN(multitopic_reader_impl,\n"
      "                   MultiTopicDataReaderImplType());\n"
      "  return multitopic_reader_impl;\n"
      "}\n"
      "#endif /* !OPENDDS_NO_MULTI_TOPIC */\n\n"
      "#ifndef OPENDDS_NO_CONTENT_SUBSCRIPTION_PROFILE\n"
      "const OpenDDS::DCPS::MetaStruct& " << ts_short_name << "TypeSupportImpl::getMetaStructForType() const\n"
      "{\n"
      "  return OpenDDS::DCPS::getMetaStruct<" << short_name << ">();\n"
      "}\n"
      "#endif /* !OPENDDS_NO_CONTENT_SUBSCRIPTION_PROFILE */\n\n"
      "namespace {\n"
      "  OpenDDS::DCPS::TypeSupportInitializer<" << ts_short_name << "TypeSupportImpl> ts_init_" << name_underscores << ";\n"
      "}\n"
      "\n"
      "const OpenDDS::XTypes::TypeIdentifier& " << ts_short_name << "TypeSupportImpl::getMinimalTypeIdentifier() const\n"
      "{\n";

    const bool java_ts_only = be_global->java_arg().length() > 0;
    const bool generate_xtypes = !be_global->suppress_xtypes() && !java_ts_only;
    if (generate_xtypes) {
      be_global->impl_ <<
        "  return OpenDDS::DCPS::getMinimalTypeIdentifier<" << xtag << ">();\n";
    } else {
      be_global->impl_ <<
        "  static OpenDDS::XTypes::TypeIdentifier ti;\n"
        "  return ti;\n";
    }
    be_global->impl_ <<
      "}\n\n"
      "const OpenDDS::XTypes::TypeMap& " << ts_short_name << "TypeSupportImpl::getMinimalTypeMap() const\n"
      "{\n";

    if (generate_xtypes) {
      be_global->impl_ <<
        "  return OpenDDS::DCPS::getMinimalTypeMap<" << xtag << ">();\n";
    } else {
      be_global->impl_ <<
        "  static OpenDDS::XTypes::TypeMap tm;\n"
        "  return tm;\n";
    }
    be_global->impl_ <<
      "}\n\n"
      "const OpenDDS::XTypes::TypeIdentifier& " << ts_short_name << "TypeSupportImpl::getCompleteTypeIdentifier() const\n"
      "{\n";

    const bool generate_xtypes_complete = generate_xtypes && be_global->xtypes_complete();
    if (generate_xtypes_complete) {
      be_global->impl_ <<
        "  return OpenDDS::DCPS::getCompleteTypeIdentifier<" << xtag << ">();\n";
    } else {
      be_global->impl_ <<
        "  static OpenDDS::XTypes::TypeIdentifier ti;\n"
        "  return ti;\n";
    }
    be_global->impl_ <<
      "}\n\n"
      "const OpenDDS::XTypes::TypeMap& " << ts_short_name << "TypeSupportImpl::getCompleteTypeMap() const\n"
      "{\n";

    if (generate_xtypes_complete) {
      be_global->impl_ <<
        "  return OpenDDS::DCPS::getCompleteTypeMap<" << xtag << ">();\n";
    } else {
      be_global->impl_ <<
        "  static OpenDDS::XTypes::TypeMap tm;\n"
        "  return tm;\n";
    }
    be_global->add_cpp_include("dds/DCPS/JsonValueReader.h");
    be_global->add_cpp_include("dds/DCPS/JsonValueWriter.h");
    const bool alloc_out = be_global->language_mapping() != BE_GlobalData::LANGMAP_CXX11 && size_type == AST_Type::VARIABLE;
    be_global->impl_ <<
      "}\n\n"
      "::DDS::ReturnCode_t " << ts_short_name << "TypeSupportImpl::encode_to_string(const " << short_name << "& in, CORBA::String_out out, OpenDDS::DCPS::RepresentationFormat* format)\n"
      "{\n"
      "#if OPENDDS_HAS_JSON_VALUE_WRITER\n"
      "  OpenDDS::DCPS::JsonRepresentationFormat_var jrf = OpenDDS::DCPS::JsonRepresentationFormat::_narrow(format);\n"
      "  if (jrf) {\n"
      "    rapidjson::StringBuffer buffer;\n"
      "    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);\n"
      "    OpenDDS::DCPS::JsonValueWriter<rapidjson::Writer<rapidjson::StringBuffer> > jvw(writer);\n"
      "    vwrite(jvw, in);\n"
      "    out = buffer.GetString();\n"
      "    return ::DDS::RETCODE_OK;\n"
      "  }\n"
      "#else\n"
      "  ACE_UNUSED_ARG(in);\n"
      "  ACE_UNUSED_ARG(format);\n"
      "#endif\n"
      "  out = \"\";\n"
      "  return ::DDS::RETCODE_UNSUPPORTED;\n"
      "}\n\n"
      "::DDS::ReturnCode_t " << ts_short_name << "TypeSupportImpl::encode_to_bytes(const " << short_name << "& in, ::DDS::OctetSeq_out out, OpenDDS::DCPS::RepresentationFormat* format)\n"
      "{\n"
      "#if OPENDDS_HAS_JSON_VALUE_WRITER\n"
      "  OpenDDS::DCPS::JsonRepresentationFormat_var jrf = OpenDDS::DCPS::JsonRepresentationFormat::_narrow(format);\n"
      "  if (jrf) {\n"
      "    CORBA::String_var buffer;\n"
      "    const ::DDS::ReturnCode_t ret = encode_to_string(in, buffer, format);\n"
      "    if (ret == ::DDS::RETCODE_OK) {\n"
      "      const ::DDS::UInt32 len = static_cast< ::DDS::UInt32>(std::strlen(buffer));\n"
      "      out = new ::DDS::OctetSeq(len);\n"
      "      out->length(len);\n"
      "      std::memcpy(out->get_buffer(), buffer, len);\n"
      "      return ::DDS::RETCODE_OK;\n"
      "    } else {\n"
      "      out = new ::DDS::OctetSeq();\n"
      "      return ret;\n"
      "    }\n"
      "  }\n"
      "#else\n"
      "  ACE_UNUSED_ARG(in);\n"
      "  ACE_UNUSED_ARG(format);\n"
      "#endif\n"
      "  out = new ::DDS::OctetSeq();\n"
      "  return ::DDS::RETCODE_UNSUPPORTED;\n"
      "}\n\n"
      "::DDS::ReturnCode_t " << ts_short_name << "TypeSupportImpl::decode_from_string(const char* in, " << short_name << "_out " <<
      (alloc_out ? "out" : "param") << ", OpenDDS::DCPS::RepresentationFormat* format)\n"
      "{\n";

    if (alloc_out) {
      be_global->impl_ << "  out = new " << short_name << ";\n";
    } else {
      be_global->impl_ <<  "  " << short_name << "* out = &param;\n";
    }

    be_global->impl_ <<
      "  OpenDDS::DCPS::set_default(*out);\n"
      "#if OPENDDS_HAS_JSON_VALUE_READER\n"
      "  OpenDDS::DCPS::JsonRepresentationFormat_var jrf = OpenDDS::DCPS::JsonRepresentationFormat::_narrow(format);\n"
      "  if (jrf) {\n"
      "    rapidjson::StringStream buffer(in);\n"
      "    OpenDDS::DCPS::JsonValueReader<> jvr(buffer);\n" <<
      "    return vread(jvr, *out) ? ::DDS::RETCODE_OK : ::DDS::RETCODE_ERROR;\n"
      "  }\n"
      "#else\n"
      "  ACE_UNUSED_ARG(in);\n"
      "  ACE_UNUSED_ARG(format);\n"
      "#endif\n"
      "  return ::DDS::RETCODE_UNSUPPORTED;\n"
      "}\n\n"
      "::DDS::ReturnCode_t " << ts_short_name << "TypeSupportImpl::decode_from_bytes(const ::DDS::OctetSeq& in, " << short_name << "_out out, OpenDDS::DCPS::RepresentationFormat* format)\n"
      "{\n"
      "#if OPENDDS_HAS_JSON_VALUE_READER\n"
      "  OpenDDS::DCPS::JsonRepresentationFormat_var jrf = OpenDDS::DCPS::JsonRepresentationFormat::_narrow(format);\n"
      "  if (jrf) {\n"
      "    return decode_from_string(reinterpret_cast<const char*>(in.get_buffer()), out, format);\n"
      "  }\n"
      "#else\n"
      "  ACE_UNUSED_ARG(in);\n"
      "  ACE_UNUSED_ARG(format);\n"
      "#endif\n"
      "  out = " << (alloc_out ? "new " : "") << short_name << "();\n"
      "  return ::DDS::RETCODE_UNSUPPORTED;\n"
      "}\n\n"
      << ts_short_name << "TypeSupport::_ptr_type " << ts_short_name << "TypeSupportImpl::_narrow(CORBA::Object_ptr obj)\n"
      "{\n"
      "  return TypeSupportType::_narrow(obj);\n"
      "}\n";
  }
  be_global->impl_ << be_global->versioning_end() << "\n";

  if (be_global->face_ts()) {
    if (node->node_type() == AST_Decl::NT_struct) {
      face_ts_generator::generate(name);
    } else {
      idl_global->err()->misc_error(
        "Generating FACE type support for Union topic types is not supported", node);
      return false;
    }
  }

  return true;
}

Member Data Documentation

idl_template_

std::string ts_generator::idl_template_

private

Definition at line 40 of file ts_generator.h.

Referenced by generate_ts().

---

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

• ts_generator.h
• ts_generator.cpp