dds_generator.h File Reference

#include "be_extern.h"
#include "be_util.h"
#include <dds/DCPS/ValueHelper.h>
#include <utl_scoped_name.h>
#include <utl_identifier.h>
#include <utl_string.h>
#include <ast.h>
#include <ast_component_fwd.h>
#include <ast_eventtype_fwd.h>
#include <ast_structure_fwd.h>
#include <ast_union_fwd.h>
#include <ast_valuetype_fwd.h>
#include <ace/CDR_Base.h>
#include <string>
#include <vector>
#include <cstring>
#include <set>
#include <stdexcept>
#include <iomanip>
#include <cctype>
#include <climits>

Include dependency graph for dds_generator.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	dds_generator
class	composite_generator
struct	NamespaceGuard
struct	ScopedNamespaceGuard
struct	Function
class	PreprocessorIfGuard
struct	NestedForLoops
struct	Intro
class	Fields
class	Fields::Iterator
struct	RefWrapper

Namespaces
	AstTypeClassification

Typedefs
typedef size_t	AstTypeClassification::Classification
typedef std::string(*	CommonFn) (const std::string &indent, AST_Decl *node, const std::string &name, AST_Type *type, const std::string &prefix, bool wrap_nested_key_only, Intro &intro, const std::string &)

Enumerations
enum	EscapeContext { EscapeContext_ForGenIdl, EscapeContext_FromGenIdl, EscapeContext_StripEscapes, EscapeContext_Normal }
enum	WrapDirection { WD_OUTPUT, WD_INPUT }
enum	FieldFilter { FieldFilter_All, FieldFilter_NestedKeyOnly, FieldFilter_KeyOnly }

Functions
std::string	canonical_name (UTL_ScopedName *sn)
std::string	canonical_name (Identifier *id)
std::string	canonical_name (AST_Decl *node)
std::string	scoped (UTL_ScopedName *sn, EscapeContext ec=EscapeContext_Normal)
std::string	module_scope (UTL_ScopedName *sn)
AST_Type *	AstTypeClassification::resolveActualType (AST_Type *element)
Classification	AstTypeClassification::classify (AST_Type *type)
std::string	wrapPrefix (AST_Type *type, WrapDirection wd)
std::string	string_type (AstTypeClassification::Classification cls)
std::string	to_cxx_type (AST_Type *type, std::size_t &size)
std::string	getWrapper (const std::string &name, AST_Type *type, WrapDirection wd)
std::string	getEnumLabel (AST_Expression *label_val, AST_Type *disc)
std::ostream &	operator<< (std::ostream &o, const AST_Expression::AST_ExprValue &ev)
std::string	bounded_arg (AST_Type *type)
std::string	type_to_default (const std::string &indent, AST_Type *type, const std::string &name, bool is_anonymous=false, bool is_union=false)
void	generateBranchLabels (AST_UnionBranch *branch, AST_Type *discriminator, size_t &n_labels, bool &has_default)
bool	needSyntheticDefault (AST_Type *disc, size_t n_labels)
std::string	field_type_name (AST_Field *field, AST_Type *field_type=0)
AST_Type *	deepest_named_type (AST_Type *type)
void	generateCaseBody (CommonFn commonFn, CommonFn commonFn2, AST_UnionBranch *branch, const char *statementPrefix, const char *namePrefix, const char *uni, bool generateBreaks, bool parens)
bool	generateSwitchBody (AST_Union *, CommonFn commonFn, const std::vector< AST_UnionBranch *> &branches, AST_Type *discriminator, const char *statementPrefix, const char *namePrefix="", const char *uni="", bool forceDisableDefault=false, bool parens=true, bool breaks=true, CommonFn commonFn2=0)
bool	generateSwitchForUnion (AST_Union *u, const char *switchExpr, CommonFn commonFn, const std::vector< AST_UnionBranch *> &branches, AST_Type *discriminator, const char *statementPrefix, const char *namePrefix="", const char *uni="", bool forceDisableDefault=false, bool parens=true, bool breaks=true, CommonFn commonFn2=0)
	returns true if a default: branch was generated (no default: label in IDL) More...
std::string	insert_cxx11_accessor_parens (const std::string &full_var_name_, bool is_union_member=false)
AST_Field *	get_struct_field (AST_Structure *struct_node, unsigned index)
bool	struct_has_explicit_keys (AST_Structure *node)
ACE_CDR::ULong	array_element_count (AST_Array *arr)
ACE_CDR::ULong	container_element_limit (AST_Type *type)
AST_Type *	container_base_type (AST_Type *type)
bool	needs_nested_key_only (AST_Type *type)
bool	needs_forany (AST_Type *type)
bool	needs_distinct_type (AST_Type *type)
std::string	strip_shift_op (const std::string &s)
const char *	get_shift_op (const std::string &s)

Variables
const Classification	AstTypeClassification::CL_UNKNOWN = 0
const Classification	AstTypeClassification::CL_SCALAR = 1
const Classification	AstTypeClassification::CL_PRIMITIVE = 2
const Classification	AstTypeClassification::CL_STRUCTURE = 4
const Classification	AstTypeClassification::CL_STRING = 8
const Classification	AstTypeClassification::CL_ENUM = 16
const Classification	AstTypeClassification::CL_UNION = 32
const Classification	AstTypeClassification::CL_ARRAY = 64
const Classification	AstTypeClassification::CL_SEQUENCE = 128
const Classification	AstTypeClassification::CL_WIDE = 256
const Classification	AstTypeClassification::CL_BOUNDED = 512
const Classification	AstTypeClassification::CL_INTERFACE = 1024
const Classification	AstTypeClassification::CL_FIXED = 2048
const char *const	shift_out = "<< "
const char *const	shift_in = ">> "

Typedef Documentation

CommonFn

typedef std::string(* CommonFn) (const std::string &indent, AST_Decl *node, const std::string &name, AST_Type *type, const std::string &prefix, bool wrap_nested_key_only, Intro &intro, const std::string &)

Definition at line 799 of file dds_generator.h.

Enumeration Type Documentation

EscapeContext

enum EscapeContext

How to handle IDL underscore escaping. Depends on where the name is going and where the name came from.

Enumerator
EscapeContext_ForGenIdl	This is for generated IDL. (Like *TypeSupport.idl)
EscapeContext_FromGenIdl	This is for a name coming from generated IDL. (Like *TypeSupportC.h)
EscapeContext_StripEscapes	Strip any escapes.
EscapeContext_Normal	This is for everything else.

Definition at line 37 of file dds_generator.h.

                   {
  /// This is for generated IDL. (Like *TypeSupport.idl)
  EscapeContext_ForGenIdl,
  /// This is for a name coming from generated IDL. (Like *TypeSupportC.h)
  EscapeContext_FromGenIdl,
  /// Strip any escapes
  EscapeContext_StripEscapes,
  /// This is for everything else.
  EscapeContext_Normal,
};

FieldFilter

enum FieldFilter

Enumerator
FieldFilter_All
FieldFilter_NestedKeyOnly
FieldFilter_KeyOnly

Definition at line 1070 of file dds_generator.h.

                 {
  FieldFilter_All,
  FieldFilter_NestedKeyOnly,
  FieldFilter_KeyOnly
};

WrapDirection

enum WrapDirection

Enumerator
WD_OUTPUT
WD_INPUT

Definition at line 477 of file dds_generator.h.

{WD_OUTPUT, WD_INPUT};

Function Documentation

array_element_count()

ACE_CDR::ULong array_element_count ( AST_Array *  arr )

inline

Definition at line 1221 of file dds_generator.h.

Referenced by container_element_limit(), marshal_generator::gen_enum(), metaclass_generator::gen_typedef(), and generate_anon_fields().

{
  ACE_CDR::ULong count = 1;
  for (ACE_CDR::ULong i = 0; i < arr->n_dims(); ++i) {
    count *= arr->dims()[i]->ev()->u.ulval;
  }
  return count;
}

bounded_arg()

std::string bounded_arg ( AST_Type *  type )

inline

Definition at line 694 of file dds_generator.h.

References AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::classify(), name, and type_to_default().

Referenced by marshal_generator::gen_enum(), marshal_generator::gen_typedef(), and generateCaseBody().

{
  using namespace AstTypeClassification;
  std::ostringstream arg;
  const Classification cls = classify(type);
  if (cls & CL_STRING) {
    AST_String* const str = dynamic_cast<AST_String*>(type);
    arg << str->max_size()->ev()->u.ulval;
  } else if (cls & CL_SEQUENCE) {
    AST_Sequence* const seq = dynamic_cast<AST_Sequence*>(type);
    arg << seq->max_size()->ev()->u.ulval;
  }
  return arg.str();
}

canonical_name() [1/3]

std::string canonical_name ( UTL_ScopedName *  sn )

inline

Definition at line 119 of file dds_generator.h.

References EscapeContext_StripEscapes, and dds_generator::scoped_helper().

Referenced by canonical_name(), marshal_generator::gen_enum(), value_reader_generator::gen_enum(), value_writer_generator::gen_enum(), metaclass_generator::gen_enum(), marshal_generator::gen_field_getValueFromSerialized(), value_writer_generator::gen_struct(), value_reader_generator::gen_struct(), typeobject_generator::generate_alias_type_identifier(), typeobject_generator::generate_array_type_identifier(), typeobject_generator::generate_enum_type_identifier(), typeobject_generator::generate_struct_type_identifier(), typeobject_generator::generate_union_type_identifier(), invalid_option(), TopicKeys::Iterator::path_i(), and typeobject_generator::strong_connect().

{
  // NOTE: Names should not have leading "::" according to the XTypes spec.
  return dds_generator::scoped_helper(sn, "::", EscapeContext_StripEscapes);
}

canonical_name() [2/3]

std::string canonical_name ( Identifier *  id )

inline

Definition at line 125 of file dds_generator.h.

References EscapeContext_StripEscapes, and dds_generator::to_string().

{
  return dds_generator::to_string(id, EscapeContext_StripEscapes);
}

canonical_name() [3/3]

std::string canonical_name ( AST_Decl *  node )

inline

Definition at line 130 of file dds_generator.h.

References canonical_name().

{
  return canonical_name(node->local_name());
}

container_base_type()

AST_Type* container_base_type ( AST_Type *  type )

inline

Definition at line 1245 of file dds_generator.h.

References AstTypeClassification::resolveActualType().

Referenced by FieldInfo::EleLen::EleLen().

{
  AST_Type* const act = AstTypeClassification::resolveActualType(type);
  AST_Sequence* const seq = dynamic_cast<AST_Sequence*>(act);
  AST_Array* const arr = dynamic_cast<AST_Array*>(act);
  if (seq) {
    return seq->base_type();
  } else if (arr) {
    return arr->base_type();
  }
  return 0;
}

container_element_limit()

ACE_CDR::ULong container_element_limit ( AST_Type *  type )

inline

Definition at line 1231 of file dds_generator.h.

References array_element_count(), and AstTypeClassification::resolveActualType().

{
  AST_Type* const act = AstTypeClassification::resolveActualType(type);
  AST_Sequence* const seq = dynamic_cast<AST_Sequence*>(act);
  AST_Array* const arr = dynamic_cast<AST_Array*>(act);
  if (seq && !seq->unbounded()) {
    return seq->max_size()->ev()->u.ulval;
  } else if (arr) {
    return array_element_count(arr);
  }
  return 0;
}

deepest_named_type()

AST_Type* deepest_named_type

(

AST_Type *

type

)

For the some situations, like a tag name, the type name we need is the deepest named type, not the actual type. This will be the name of the deepest typedef if it's an array or sequence, otherwise the name of the type.

Definition at line 442 of file dds_generator.cpp.

Referenced by field_type_name(), marshal_generator::gen_enum(), marshal_generator::gen_field_getValueFromSerialized(), metaclass_generator::gen_typedef(), gen_union_branch(), generate_anon_fields(), Intro::insert(), and type_to_default_array().

{
  AST_Type* consider = type;
  AST_Type* named_type = type;
  while (consider->node_type() == AST_Decl::NT_typedef) {
    named_type = consider;
    consider = dynamic_cast<AST_Typedef*>(named_type)->base_type();
  }
  return named_type;
}

field_type_name()

std::string field_type_name	(	AST_Field *	field,
		AST_Type *	field_type = 0
	)

Definition at line 425 of file dds_generator.cpp.

References FieldInfo::as_base_, AstTypeClassification::CL_STRING, AstTypeClassification::classify(), deepest_named_type(), name, scoped(), FieldInfo::scoped_type_, string_type(), and FieldInfo::type_.

Referenced by marshal_generator::gen_field_getValueFromSerialized(), marshal_generator::gen_typedef(), gen_union_branch(), generateCaseBody(), and Intro::insert().

{
  if (!field_type) {
    field_type = field->field_type();
  }
  const Classification cls = classify(field_type);
  const std::string name = (cls & CL_STRING) ?
    string_type(cls) : scoped(deepest_named_type(field_type)->name());
  if (field) {
    FieldInfo af(*field);
    if (af.as_base_ && af.type_->anonymous()) {
      return af.scoped_type_;
    }
  }
  return name;
}

generateBranchLabels()

void generateBranchLabels ( AST_UnionBranch *  branch, AST_Type *  discriminator, size_t &  n_labels, bool &  has_default  )

inline

Definition at line 713 of file dds_generator.h.

References be_global, and getEnumLabel().

Referenced by generateSwitchBody().

{
  for (unsigned long j = 0; j < branch->label_list_length(); ++j) {
    ++n_labels;
    AST_UnionLabel* label = branch->label(j);
    if (label->label_kind() == AST_UnionLabel::UL_default) {
      be_global->impl_ << "  default:";
      has_default = true;
    } else if (discriminator->node_type() == AST_Decl::NT_enum) {
      be_global->impl_ << "  case "
        << getEnumLabel(label->label_val(), discriminator) << ':';
    } else {
      be_global->impl_ << "  case " << *label->label_val()->ev() << ':';
    }
    be_global->impl_<< ((j == branch->label_list_length() - 1) ? " {\n" : "\n");
  }
}

generateCaseBody()

void generateCaseBody ( CommonFn  commonFn, CommonFn  commonFn2, AST_UnionBranch *  branch, const char *  statementPrefix, const char *  namePrefix, const char *  uni, bool  generateBreaks, bool  parens  )

inline

Definition at line 806 of file dds_generator.h.

References be_global, bounded_arg(), AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_BOUNDED, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), field_type_name(), dds_generator::get_tag_name(), getWrapper(), Intro::join(), name, AstTypeClassification::resolveActualType(), tryconstructfailaction_trim, tryconstructfailaction_use_default, type_to_default(), and WD_INPUT.

Referenced by generateSwitchBody(), and generateSwitchForUnion().

{
  using namespace AstTypeClassification;
  const BE_GlobalData::LanguageMapping lmap = be_global->language_mapping();
  const bool use_cxx11 = lmap == BE_GlobalData::LANGMAP_CXX11;
  const std::string name = branch->local_name()->get_string();
  if (namePrefix == std::string(">> ")) {
    std::string brType = field_type_name(branch, branch->field_type());
    std::string forany;
    AST_Type* br = resolveActualType(branch->field_type());
    Classification br_cls = classify(br);
    if (!br->in_main_file()
        && br->node_type() != AST_Decl::NT_pre_defined) {
      be_global->add_referenced(br->file_name().c_str());
    }

    std::string rhs;
    const bool is_face = lmap == BE_GlobalData::LANGMAP_FACE_CXX;
    const bool is_wide = br_cls & CL_WIDE;
    const bool is_bound_string = (br_cls & (CL_STRING | CL_BOUNDED)) == (CL_STRING | CL_BOUNDED);
    const std::string bound_string_suffix = (is_bound_string && !is_face) ? ".c_str()" : "";

    if (is_bound_string) {
      const std::string to_type = is_face ? is_wide ? "ACE_InputCDR::to_wstring" : "ACE_InputCDR::to_string"
        : is_wide ? "Serializer::ToBoundedString<wchar_t>" : "Serializer::ToBoundedString<char>";
      const std::string face_suffix = is_face ? ".out()" : "";
      brType = is_face ? is_wide ? "FACE::WString_var" : "FACE::String_var"
        : is_wide ? "OPENDDS_WSTRING" : "OPENDDS_STRING";
      rhs = to_type + "(tmp" + face_suffix + ", " + bounded_arg(br) + ")";
    } else if (br_cls & CL_STRING) {
      const std::string nmspace = is_face ? "FACE::" : "CORBA::";
      brType = use_cxx11 ? std::string("std::") + (is_wide ? "w" : "") + "string"
        : nmspace + (is_wide ? "W" : "") + "String_var";
      rhs = use_cxx11 ? "tmp" : "tmp.out()";
    } else if (use_cxx11 && (br_cls & (CL_ARRAY | CL_SEQUENCE))) {  //array or seq C++11
      rhs = "IDL::DistinctType<" + brType + ", "
        + dds_generator::get_tag_name(brType)
        + ">(tmp)";
    } else if (br_cls & CL_ARRAY) { //array classic
      forany = "    " + brType + "_forany fa = tmp;\n";
      rhs = getWrapper("fa", br, WD_INPUT);
    } else { // anything else
      rhs = getWrapper("tmp", br, WD_INPUT);
    }

    if (*statementPrefix) {
      be_global->impl_ << statementPrefix;
    }
    be_global->impl_ <<
      "    " << brType << " tmp;\n" << forany <<
      "    if (strm >> " << rhs << ") {\n"
      "      uni." << name << (use_cxx11 ? "(std::move(tmp));\n" : "(tmp" + bound_string_suffix + ");\n") <<
      "      uni._d(disc);\n"
      "      return true;\n"
      "    }\n";

    if (be_global->try_construct(branch) == tryconstructfailaction_use_default) {
      be_global->impl_ <<
        type_to_default("        ", br, "uni." + name, branch->anonymous(), true) <<
        "        strm.set_construction_status(Serializer::ConstructionSuccessful);\n"
        "        return true;\n";
    } else if ((be_global->try_construct(branch) == tryconstructfailaction_trim) && (br_cls & CL_BOUNDED) &&
                (br_cls & (CL_STRING | CL_SEQUENCE))) {
      if (is_bound_string) {
        const std::string check_not_empty = "!tmp.empty()";
        const std::string get_length = use_cxx11 ? "tmp.length()" : "ACE_OS::strlen(tmp.c_str())";
        const std::string inout = use_cxx11 ? "" : ".inout()";
        const std::string strtype = br_cls & CL_WIDE ? "std::wstring" : "std::string";
        be_global->impl_ <<
          "        if (strm.get_construction_status() == Serializer::BoundConstructionFailure && " << check_not_empty << " && ("
                    << bounded_arg(br) << " < " << get_length << ")) {\n"
          "          " << strtype << " s = tmp.c_str();\n"
          "          s.resize(" << bounded_arg(br) << ");\n"
          "          uni." << name << "(s.c_str());\n"
          "          strm.set_construction_status(Serializer::ConstructionSuccessful);\n"
          "          return true;\n"
          "        } else {\n"
          "          strm.set_construction_status(Serializer::ElementConstructionFailure);\n"
          "          return false;\n"
          "        }\n";
      } else if (br_cls & CL_SEQUENCE) {
        be_global->impl_ <<
          "        if(strm.get_construction_status() == Serializer::ElementConstructionFailure) {\n"
          "          return false;\n"
          "        }\n"
          "        uni." << name << (use_cxx11 ? "(std::move(tmp));\n" : "(tmp);\n") <<
          "        uni._d(disc);\n"
          "        strm.set_construction_status(Serializer::ConstructionSuccessful);\n"
          "        return true;\n";
      }
    } else {
      //discard/default
      be_global->impl_ <<
        "        strm.set_construction_status(Serializer::ElementConstructionFailure);\n"
        "        return false;\n  ";
    }
  } else {
    const char* breakString = generateBreaks ? "    break;\n" : "";
    const std::string indent = "    ";
    Intro intro;
    std::ostringstream contents;
    if (commonFn2) {
      const OpenDDS::XTypes::MemberId id = be_global->get_id(branch);
      contents
        << commonFn2(indent, branch, name + (parens ? "()" : ""), branch->field_type(), "uni", false, intro, "")
        << indent << "if (!strm.write_parameter_id(" << id << ", size)) {\n"
        << indent << "  return false;\n"
        << indent << "}\n";
    }
    const std::string expr = commonFn(indent, branch,
      name + (parens ? "()" : ""), branch->field_type(),
      std::string(namePrefix) + "uni", false, intro, uni);
    if (*statementPrefix) {
      contents <<
        indent << statementPrefix << " " << expr << ";\n" <<
        (statementPrefix == std::string("return") ? "" : breakString);
    } else {
      contents << expr << breakString;
    }
    intro.join(be_global->impl_, indent);
    be_global->impl_ << contents.str();
  }
}

generateSwitchBody()

bool generateSwitchBody ( AST_Union *  , CommonFn  commonFn, const std::vector< AST_UnionBranch *> &  branches, AST_Type *  discriminator, const char *  statementPrefix, const char *  namePrefix = "", const char *  uni = "", bool  forceDisableDefault = false, bool  parens = true, bool  breaks = true, CommonFn  commonFn2 = 0  )

inline

Definition at line 934 of file dds_generator.h.

References be_global, generateBranchLabels(), generateCaseBody(), and needSyntheticDefault().

Referenced by marshal_generator::gen_field_getValueFromSerialized(), and generateSwitchForUnion().

{
  size_t n_labels = 0;
  bool has_default = false;
  for (size_t i = 0; i < branches.size(); ++i) {
    AST_UnionBranch* branch = branches[i];
    if (forceDisableDefault) {
      bool foundDefault = false;
      for (unsigned long j = 0; j < branch->label_list_length(); ++j) {
        if (branch->label(j)->label_kind() == AST_UnionLabel::UL_default) {
          foundDefault = true;
        }
      }
      if (foundDefault) {
        has_default = true;
        continue;
      }
    }
    generateBranchLabels(branch, discriminator, n_labels, has_default);
    generateCaseBody(commonFn, commonFn2, branch, statementPrefix, namePrefix,
                     uni, breaks, parens);
    be_global->impl_ <<
      "  }\n";
  }
  if (!has_default && needSyntheticDefault(discriminator, n_labels)) {
    be_global->impl_ <<
      "  default:\n" <<
      ((namePrefix == std::string(">> ")) ? "    uni._d(disc);\n" : "") <<
      "    break;\n";
    return true;
  }
  return false;
}

generateSwitchForUnion()

bool generateSwitchForUnion ( AST_Union *  u, const char *  switchExpr, CommonFn  commonFn, const std::vector< AST_UnionBranch *> &  branches, AST_Type *  discriminator, const char *  statementPrefix, const char *  namePrefix = "", const char *  uni = "", bool  forceDisableDefault = false, bool  parens = true, bool  breaks = true, CommonFn  commonFn2 = 0  )

inline

returns true if a default: branch was generated (no default: label in IDL)

Definition at line 975 of file dds_generator.h.

References be_global, generateCaseBody(), generateSwitchBody(), and AstTypeClassification::resolveActualType().

Referenced by marshal_generator::gen_field_getValueFromSerialized(), marshal_generator::gen_union(), value_writer_generator::gen_union(), value_reader_generator::gen_union(), metaclass_generator::gen_union(), GeneratorBase::gen_union(), and Cxx11Generator::gen_union().

{
  using namespace AstTypeClassification;
  AST_Type* dt = resolveActualType(discriminator);
  AST_PredefinedType* bt = dynamic_cast<AST_PredefinedType*>(dt);
  if (bt && bt->pt() == AST_PredefinedType::PT_boolean) {
    AST_UnionBranch* true_branch = 0;
    AST_UnionBranch* false_branch = 0;
    AST_UnionBranch* default_branch = 0;
    for (std::vector<AST_UnionBranch*>::const_iterator pos = branches.begin(),
         limit = branches.end(); pos != limit; ++pos) {
      AST_UnionBranch* branch = *pos;
      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) {
          default_branch = branch;
        } else if (label->label_val()->ev()->u.bval) {
          true_branch = branch;
        } else if (!label->label_val()->ev()->u.bval) {
          false_branch = branch;
        }
      }
    }

    if (true_branch || false_branch) {
      be_global->impl_ <<
        "  if (" << switchExpr << ") {\n";
    } else {
      be_global->impl_ <<
        "  {\n";
    }

    if (true_branch || default_branch) {
      generateCaseBody(commonFn, commonFn2, true_branch ? true_branch : default_branch,
                       statementPrefix, namePrefix, uni, false, parens);
    }

    if (false_branch || (default_branch && true_branch)) {
      be_global->impl_ <<
        "  } else {\n";
      generateCaseBody(commonFn, commonFn2, false_branch ? false_branch : default_branch,
                       statementPrefix, namePrefix, uni, false, parens);
    }

    be_global->impl_ <<
      "  }\n";

    return !default_branch && bool(true_branch) != bool(false_branch);

  } else {
    be_global->impl_ <<
      "  switch (" << switchExpr << ") {\n";
    bool b(generateSwitchBody(u, commonFn, branches, discriminator,
                              statementPrefix, namePrefix, uni,
                              forceDisableDefault, parens, breaks,
                              commonFn2));
    be_global->impl_ <<
      "  }\n";
    return b;
  }
}

get_shift_op()

const char* get_shift_op ( const std::string &  s )

inline

Definition at line 1348 of file dds_generator.h.

References shift_in, and shift_out.

{
  const size_t shift_len = 3;
  if (s.size() > shift_len) {
    const std::string first3 = s.substr(0, shift_len);
    if (first3 == shift_in) {
      return shift_in;
    }
    if (first3 == shift_out) {
      return shift_out;
    }
  }
  return "";
}

get_struct_field()

AST_Field* get_struct_field ( AST_Structure *  struct_node, unsigned  index  )

inline

Definition at line 1077 of file dds_generator.h.

Referenced by marshal_generator::gen_typedef(), Fields::Iterator::operator*(), and struct_has_explicit_keys().

{
  if (!struct_node || index >= struct_node->nfields()) {
    return 0;
  }
  AST_Field** field_ptrptr;
  struct_node->field(field_ptrptr, index);
  return field_ptrptr ? *field_ptrptr : 0;
}

getEnumLabel()

std::string getEnumLabel ( AST_Expression *  label_val, AST_Type *  disc  )

inline

Definition at line 618 of file dds_generator.h.

References be_global, and scoped().

Referenced by generateBranchLabels(), GeneratorBase::GenerateUnionAccessors::operator()(), and Cxx11Generator::union_accessors().

{
  std::string e = scoped(disc->name()),
    label = label_val->n()->last_component()->get_string();
  if (be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11) {
    return e + "::" + label;
  }
  const size_t colon = e.rfind("::");
  if (colon == std::string::npos) {
    return label;
  }
  return e.replace(colon + 2, std::string::npos, label);
}

getWrapper()

std::string getWrapper ( const std::string &  name, AST_Type *  type, WrapDirection  wd  )

inline

Definition at line 603 of file dds_generator.h.

References be_global, AstTypeClassification::CL_BOUNDED, AstTypeClassification::CL_STRING, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), WD_OUTPUT, and wrapPrefix().

Referenced by marshal_generator::gen_enum(), marshal_generator::gen_field_getValueFromSerialized(), marshal_generator::gen_typedef(), marshal_generator::gen_union(), metaclass_generator::gen_union(), marshal_generator::gen_union_default(), and generateCaseBody().

{
  using namespace AstTypeClassification;
  if (be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11) {
    const Classification cls = classify(type);
    if ((cls & (CL_BOUNDED | CL_STRING)) == (CL_BOUNDED | CL_STRING)) {
      return (wd == WD_OUTPUT ? "Serializer::FromBoundedString" : "Serializer::ToBoundedString")
        + std::string(cls & CL_WIDE ? "<wchar_t>(" : "<char>(") + name + ')';
    }
  }
  std::string pre = wrapPrefix(type, wd);
  return (pre.empty()) ? name : (pre + name + ')');
}

insert_cxx11_accessor_parens()

std::string insert_cxx11_accessor_parens ( const std::string &  full_var_name_, bool  is_union_member = false  )

inline

Definition at line 1043 of file dds_generator.h.

References be_global.

Referenced by keys_generator::gen_struct(), and marshal_generator::gen_typedef().

{
  const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
  if (!use_cxx11 || is_union_member || full_var_name_.empty()) {
    return full_var_name_;
  }

  std::string full_var_name(full_var_name_);
  std::string::size_type n = 0;
  while ((n = full_var_name.find('.', n)) != std::string::npos) {
    if (full_var_name[n-1] != ']') {
      full_var_name.insert(n, "()");
      n += 3;
    } else {
      ++n;
    }
  }
  n = 0;
  while ((n = full_var_name.find('[', n)) != std::string::npos) {
    full_var_name.insert(n, "()");
    n += 3;
  }
  return full_var_name[full_var_name.size() - 1] == ']'
    ? full_var_name : full_var_name + "()";
}

module_scope()

std::string module_scope ( UTL_ScopedName *  sn )

inline

Definition at line 367 of file dds_generator.h.

References dds_generator::module_scope_helper().

Referenced by value_writer_generator::gen_enum().

{
  return dds_generator::module_scope_helper(sn, "::");
}

needs_distinct_type()

bool needs_distinct_type ( AST_Type *  type )

inline

Definition at line 1324 of file dds_generator.h.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

Referenced by RefWrapper::done().

{
  using namespace AstTypeClassification;
  const Classification type_class = classify(resolveActualType(type));
  return be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11 &&
    type_class & (CL_SEQUENCE | CL_ARRAY);
}

needs_forany()

bool needs_forany ( AST_Type *  type )

inline

Definition at line 1316 of file dds_generator.h.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

Referenced by RefWrapper::done().

{
  using namespace AstTypeClassification;
  const Classification type_class = classify(resolveActualType(type));
  return be_global->language_mapping() != BE_GlobalData::LANGMAP_CXX11 &&
    type_class & CL_ARRAY;
}

needs_nested_key_only()

bool needs_nested_key_only ( AST_Type *  type )

inline

Returns true for a type if nested key serialization is different from normal serialization.

Definition at line 1262 of file dds_generator.h.

References be_global, Fields::begin(), AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), Fields::end(), name, AstTypeClassification::resolveActualType(), scoped(), and struct_has_explicit_keys().

Referenced by RefWrapper::done(), and marshal_generator::gen_enum().

{
  AST_Type* const non_aliased_type = type;

  using namespace AstTypeClassification;

  static std::vector<AST_Type*> type_stack;
  type = resolveActualType(type);
  // Check if we have encountered the same type recursively
  for (size_t i = 0; i < type_stack.size(); ++i) {
    if (type == type_stack[i]) {
      return true;
    }
  }
  type_stack.push_back(type);

  bool result = false;
  const std::string name = scoped(type->name());

  std::string template_name;
  if (be_global->special_serialization(non_aliased_type, template_name)) {
    result = false;
  } else {
    const Classification type_class = classify(type);
    if (type_class & CL_ARRAY) {
      result = needs_nested_key_only(dynamic_cast<AST_Array*>(type)->base_type());
    } else if (type_class & CL_SEQUENCE) {
      result = needs_nested_key_only(dynamic_cast<AST_Sequence*>(type)->base_type());
    } else if (type_class & CL_STRUCTURE) {
      AST_Structure* const struct_node = dynamic_cast<AST_Structure*>(type);
      // TODO(iguessthislldo): Possible optimization: If everything in a struct
      // was a key recursively, then we could return false.
      if (struct_has_explicit_keys(struct_node)) {
        result = true;
      } else {
        const Fields fields(struct_node);
        const Fields::Iterator fields_end = fields.end();
        for (Fields::Iterator i = fields.begin(); i != fields_end; ++i) {
          if (needs_nested_key_only((*i)->field_type())) {
            result = true;
            break;
          }
        }
      }
    } else if (type_class & CL_UNION) {
      // A union will always be different as a key because it's just the
      // discriminator.
      result = true;
    }
  }
  type_stack.pop_back();
  return result;
}

needSyntheticDefault()

bool needSyntheticDefault ( AST_Type *  disc, size_t  n_labels  )

inline

Definition at line 733 of file dds_generator.h.

References ACE_OCTET_MAX, ACE_UINT16_MAX, and ACE_UINT32_MAX.

Referenced by generateSwitchBody(), and GeneratorBase::needsDefault().

{
  AST_Decl::NodeType nt = disc->node_type();
  if (nt == AST_Decl::NT_enum) return true;

  AST_PredefinedType* pdt = dynamic_cast<AST_PredefinedType*>(disc);
  switch (pdt->pt()) {
  case AST_PredefinedType::PT_boolean:
    return n_labels < 2;
#if OPENDDS_HAS_EXPLICIT_INTS
  case AST_PredefinedType::PT_int8:
  case AST_PredefinedType::PT_uint8:
#endif
  case AST_PredefinedType::PT_char:
  case AST_PredefinedType::PT_octet:
    return n_labels < ACE_OCTET_MAX;
  case AST_PredefinedType::PT_short:
  case AST_PredefinedType::PT_ushort:
  case AST_PredefinedType::PT_wchar:
    return n_labels < ACE_UINT16_MAX;
  case AST_PredefinedType::PT_long:
  case AST_PredefinedType::PT_ulong:
    return n_labels < ACE_UINT32_MAX;
  default:
    return true;
  }
}

operator<<()

std::ostream& operator<< ( std::ostream &  o, const AST_Expression::AST_ExprValue &  ev  )

inline

Definition at line 633 of file dds_generator.h.

References ACE_INT32_MIN, ACE_INT64_MIN, OpenDDS::DCPS::hex_value(), ACE_CDR::Fixed::MAX_STRING_SIZE, and be_util::misc_error_and_abort().

{
  using namespace OpenDDS::DCPS;
  RestoreOutputStreamState ross(o);
  switch (ev.et) {
  case AST_Expression::EV_octet:
    return hex_value(o << "0x", static_cast<int>(ev.u.oval), 1);
#if OPENDDS_HAS_EXPLICIT_INTS
  case AST_Expression::EV_int8:
    return o << static_cast<short>(ev.u.int8val);
  case AST_Expression::EV_uint8:
    return o << static_cast<unsigned short>(ev.u.uint8val);
#endif
  case AST_Expression::EV_short:
    return o << ev.u.sval;
  case AST_Expression::EV_ushort:
    return o << ev.u.usval << 'u';
  case AST_Expression::EV_long:
    return signed_int_helper<ACE_CDR::Long>(o, ev.u.lval, ACE_INT32_MIN);
  case AST_Expression::EV_ulong:
    return o << ev.u.ulval << 'u';
  case AST_Expression::EV_longlong:
    return signed_int_helper<ACE_CDR::LongLong>(o, ev.u.llval, ACE_INT64_MIN) << "LL";
  case AST_Expression::EV_ulonglong:
    return o << ev.u.ullval << "ULL";
  case AST_Expression::EV_wchar:
    return char_helper<ACE_CDR::WChar>(o << "L'", ev.u.wcval) << '\'';
  case AST_Expression::EV_char:
    return char_helper<ACE_CDR::Char>(o << '\'', ev.u.cval) << '\'';
  case AST_Expression::EV_bool:
    return o << std::boolalpha << static_cast<bool>(ev.u.bval);
  case AST_Expression::EV_float:
    return o << ev.u.fval << 'f';
  case AST_Expression::EV_double:
    return o << ev.u.dval;
  case AST_Expression::EV_wstring:
    return o << "L\"" << ev.u.wstrval << '"';
  case AST_Expression::EV_string:
    return o << '"' << ev.u.strval->get_string() << '"';
#ifdef ACE_HAS_CDR_FIXED
  case AST_Expression::EV_fixed: {
    char buf[ACE_CDR::Fixed::MAX_STRING_SIZE];
    ev.u.fixedval.to_string(buf, sizeof buf);
    return o << "\"" << buf << "\"";
  }
#endif
  case AST_Expression::EV_enum:
  case AST_Expression::EV_longdouble:
  case AST_Expression::EV_any:
  case AST_Expression::EV_object:
  case AST_Expression::EV_void:
  case AST_Expression::EV_none:
    be_util::misc_error_and_abort(
      "Unsupported ExprType value in operator<<(std::ostream, AST_ExprValue)");
  }
  be_util::misc_error_and_abort(
    "Unhandled ExprType value in operator<<(std::ostream, AST_ExprValue)");
  return o;
}

scoped()

std::string scoped ( UTL_ScopedName *  sn, EscapeContext  ec = EscapeContext_Normal  )

inline

Definition at line 358 of file dds_generator.h.

References dds_generator::scoped_helper().

Referenced by field_type_name(), GeneratorBase::gen_array_traits(), langmap_generator::gen_const(), marshal_generator::gen_enum(), value_writer_generator::gen_enum(), value_reader_generator::gen_enum(), metaclass_generator::gen_enum(), marshal_generator::gen_field_getValueFromSerialized(), marshal_generator::gen_struct(), value_writer_generator::gen_struct(), value_reader_generator::gen_struct(), metaclass_generator::gen_struct(), dynamic_data_adapter_generator::gen_typedef(), marshal_generator::gen_typedef(), metaclass_generator::gen_typedef(), marshal_generator::gen_union(), value_writer_generator::gen_union(), value_reader_generator::gen_union(), metaclass_generator::gen_union(), GeneratorBase::gen_union(), marshal_generator::gen_union_default(), java_ts_generator::generate(), face_ts_generator::generate(), generate_anon_fields(), ts_generator::generate_ts(), GeneratorBase::generateDefaultValue(), getEnumLabel(), GeneratorBase::map_type(), needs_nested_key_only(), FieldInfo::scoped_type(), to_cxx_type(), type_to_default(), type_to_default_array(), and FieldInfo::underscore().

{
  // Add the leading scope operator here to make type names "fully-qualified" and avoid
  // naming collisions with identifiers in OpenDDS::DCPS.
  // The leading space allows this string to be used directly in a <>-delimeted template
  // argument list while avoiding the <: digraph.
  return " ::" + dds_generator::scoped_helper(sn, "::", ec);
}

string_type()

std::string string_type ( AstTypeClassification::Classification  cls )

inline

Definition at line 521 of file dds_generator.h.

References be_global, and AstTypeClassification::CL_WIDE.

Referenced by field_type_name(), metaclass_generator::gen_enum(), and to_cxx_type().

{
  return be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11 ?
    ((cls & AstTypeClassification::CL_WIDE) ? "std::wstring" : "std::string") :
    (cls & AstTypeClassification::CL_WIDE) ? "TAO::WString_Manager" : "TAO::String_Manager";
}

strip_shift_op()

std::string strip_shift_op ( const std::string &  s )

inline

Definition at line 1335 of file dds_generator.h.

References shift_in, and shift_out.

{
  const size_t shift_len = 3;
  std::string rv = s;
  if (rv.size() > shift_len) {
    const std::string first3 = rv.substr(0, shift_len);
    if (first3 == shift_out || first3 == shift_in) {
      rv.erase(0, 3);
    }
  }
  return rv;
}

struct_has_explicit_keys()

bool struct_has_explicit_keys ( AST_Structure *  node )

inline

Definition at line 1088 of file dds_generator.h.

References be_global, and get_struct_field().

Referenced by Fields::explicit_keys_only(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_item_count(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_member_id_at_index(), needs_nested_key_only(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_structure_xcdr2(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialized_size_structure_xcdr2().

{
  for (unsigned i = 0; i < node->nfields(); ++i) {
    if (be_global->is_key(get_struct_field(node, i))) {
      return true;
    }
  }
  return false;
}

to_cxx_type()

std::string to_cxx_type ( AST_Type *  type, std::size_t &  size  )

inline

Definition at line 528 of file dds_generator.h.

References AstTypeClassification::CL_ENUM, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::classify(), be_util::misc_error_and_abort(), AstTypeClassification::resolveActualType(), scoped(), and string_type().

Referenced by marshal_generator::gen_field_getValueFromSerialized(), metaclass_generator::gen_typedef(), gen_union_branch(), and generate_anon_fields().

{
  const AstTypeClassification::Classification cls = AstTypeClassification::classify(type);
  if (cls & AstTypeClassification::CL_ENUM) {
    size = 4;
    return "ACE_CDR::ULong";
  }
  if (cls & AstTypeClassification::CL_STRING) {
    return string_type(cls);
  }
  if (cls & AstTypeClassification::CL_PRIMITIVE) {
    AST_Type* t = AstTypeClassification::resolveActualType(type);
    AST_PredefinedType* p = dynamic_cast<AST_PredefinedType*>(t);
    switch (p->pt()) {
    case AST_PredefinedType::PT_long:
      size = 4;
      return "ACE_CDR::Long";
    case AST_PredefinedType::PT_ulong:
      size = 4;
      return "ACE_CDR::ULong";
    case AST_PredefinedType::PT_longlong:
      size = 8;
      return "ACE_CDR::LongLong";
    case AST_PredefinedType::PT_ulonglong:
      size = 8;
      return "ACE_CDR::ULongLong";
    case AST_PredefinedType::PT_short:
      size = 2;
      return "ACE_CDR::Short";
    case AST_PredefinedType::PT_ushort:
      size = 2;
      return "ACE_CDR::UShort";
#if OPENDDS_HAS_EXPLICIT_INTS
    case AST_PredefinedType::PT_int8:
      size = 1;
      return "ACE_CDR::Int8";
    case AST_PredefinedType::PT_uint8:
      size = 1;
      return "ACE_CDR::UInt8";
#endif
    case AST_PredefinedType::PT_float:
      size = 4;
      return "ACE_CDR::Float";
    case AST_PredefinedType::PT_double:
      size = 8;
      return "ACE_CDR::Double";
    case AST_PredefinedType::PT_longdouble:
      size = 16;
      return "ACE_CDR::LongDouble";
    case AST_PredefinedType::PT_char:
      size = 1;
      return "ACE_CDR::Char";
    case AST_PredefinedType::PT_wchar:
      size = 2;
      return "ACE_CDR::WChar";
    case AST_PredefinedType::PT_boolean:
      size = 1;
      return "ACE_CDR::Boolean";
    case AST_PredefinedType::PT_octet:
      size = 1;
      return "ACE_CDR::Octet";
    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("Unsupported predefined type in to_cxx_type");
    }
    be_util::misc_error_and_abort("Unhandled predefined type in to_cxx_type");
  }
  return scoped(type->name());
}

type_to_default()

std::string type_to_default	(	const std::string &	indent,
		AST_Type *	type,
		const std::string &	name,
		bool	is_anonymous = false,
		bool	is_union = false
	)

Definition at line 359 of file dds_generator.cpp.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), AstTypeClassification::resolveActualType(), scoped(), and type_to_default_array().

Referenced by bounded_arg(), marshal_generator::gen_enum(), marshal_generator::gen_struct(), marshal_generator::gen_typedef(), marshal_generator::gen_union(), marshal_generator::gen_union_default(), and generateCaseBody().

{
  AST_Type* actual_type = resolveActualType(type);
  Classification fld_cls = classify(actual_type);
  const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
  string def_val;
  std::string pre = " = ";
  std::string post;
  if (is_union) {
    pre = "(";
    post = ")";
  }
  if (fld_cls & (CL_STRUCTURE | CL_UNION)) {
    return indent + "set_default(" + name + (is_union ? "()" : "") + ");\n";
  } else if (fld_cls & CL_ARRAY) {
    return type_to_default_array(
      indent, type, name, is_anonymous, is_union, use_cxx11, fld_cls);
  } else if (fld_cls & CL_ENUM) {
    // For now, simply return the first value of the enumeration.
    // Must be changed, if support for @default_literal is desired.
    AST_Enum* enu = dynamic_cast<AST_Enum*>(actual_type);
    UTL_ScopeActiveIterator i(enu, UTL_Scope::IK_decls);
    AST_EnumVal *item = dynamic_cast<AST_EnumVal*>(i.item());
    if (use_cxx11) {
      def_val = scoped(type->name()) + "::" + item->local_name()->get_string();
    } else {
      def_val = scoped(item->name());
    }
  } else if (fld_cls & CL_SEQUENCE) {
    string seq_resize_func = (use_cxx11) ? "resize" : "length";
    if (is_union) {
      return indent + "tmp." + seq_resize_func + "(0);\n"
        + indent + name + "(tmp);\n";
    } else {
      return indent + name + "." + seq_resize_func + "(0);\n";
    }
  } else if (fld_cls & CL_STRING) {
    def_val = (fld_cls & CL_WIDE) ? "L\"\"" : "\"\"";
    if (!use_cxx11 && (fld_cls & CL_WIDE)) def_val = "TAO::WString_Manager::s_traits::default_initializer()";
  } else if (fld_cls & (CL_PRIMITIVE | CL_FIXED)) {
    AST_PredefinedType* pt = dynamic_cast<AST_PredefinedType*>(actual_type);
    if (pt && (pt->pt() == AST_PredefinedType::PT_longdouble)) {
      if (use_cxx11) {
        def_val = "0.0L";
      } else {
        string temp_val = "ACE_CDR::LongDouble val = ACE_CDR_LONG_DOUBLE_INITIALIZER";
        if (is_union) {
          def_val = "val";
          return indent + temp_val + ";\n" +
            indent + name + pre + def_val + post + ";\n";
        } else {
          def_val = "ACE_CDR_LONG_DOUBLE_ASSIGNMENT(" + name + ", val)";
          return indent + "{\n"
            "  " + indent + temp_val + ";\n"
            "  " + indent + def_val + ";\n" +
            indent + "}\n";
        }
      }
    } else {
      def_val =  "0";
    }
  }
  return indent + name + pre + def_val + post + ";\n";
}

wrapPrefix()

std::string wrapPrefix ( AST_Type *  type, WrapDirection  wd  )

inline

Definition at line 480 of file dds_generator.h.

References WD_OUTPUT.

Referenced by getWrapper().

{
  switch (type->node_type()) {
  case AST_Decl::NT_pre_defined: {
    AST_PredefinedType* const p = dynamic_cast<AST_PredefinedType*>(type);
    switch (p->pt()) {
    case AST_PredefinedType::PT_char:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_char(" : "ACE_InputCDR::to_char(";
    case AST_PredefinedType::PT_wchar:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_wchar(" : "ACE_InputCDR::to_wchar(";
    case AST_PredefinedType::PT_octet:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_octet(" : "ACE_InputCDR::to_octet(";
    case AST_PredefinedType::PT_boolean:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_boolean(" : "ACE_InputCDR::to_boolean(";
#if OPENDDS_HAS_EXPLICIT_INTS
    case AST_PredefinedType::PT_uint8:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_uint8(" : "ACE_InputCDR::to_uint8(";
    case AST_PredefinedType::PT_int8:
      return (wd == WD_OUTPUT)
        ? "ACE_OutputCDR::from_int8(" : "ACE_InputCDR::to_int8(";
#endif
    default:
      return "";
    }
  }
  case AST_Decl::NT_string:
    return (wd == WD_OUTPUT)
      ? "ACE_OutputCDR::from_string(" : "ACE_InputCDR::to_string(";
  case AST_Decl::NT_wstring:
    return (wd == WD_OUTPUT)
      ? "ACE_OutputCDR::from_wstring(" : "ACE_InputCDR::to_wstring(";
  default:
    return "";
  }
}

Variable Documentation

shift_in

const char* const shift_in = ">> "

Definition at line 1333 of file dds_generator.h.

Referenced by RefWrapper::done(), get_shift_op(), and strip_shift_op().

shift_out

const char* const shift_out = "<< "

Definition at line 1332 of file dds_generator.h.

Referenced by get_shift_op(), and strip_shift_op().