marshal_generator.cpp File Reference

#include "marshal_generator.h"
#include "be_extern.h"
#include "utl_identifier.h"
#include <string>
#include <map>
#include <sstream>
#include <iostream>
#include <cctype>

Include dependency graph for marshal_generator.cpp:

Go to the source code of this file.

Functions
string	getMaxSizeExprPrimitive (AST_Type *type)
string	getSerializerName (AST_Type *type)
string	nameOfSeqHeader (AST_Type *elem)
string	streamAndCheck (const string &expr, size_t indent=2)
string	checkAlignment (AST_Type *elem)
bool	isRtpsSpecialSequence (const string &cxx)
bool	genRtpsSpecialSequence (const string &cxx)
void	gen_sequence (UTL_ScopedName *tdname, AST_Sequence *seq)
string	getAlignment (AST_Type *elem)
void	gen_array (UTL_ScopedName *name, AST_Array *arr)
string	getArrayForany (const char *prefix, const char *fname, const string &cxx_fld)
AST_Type *	find_type (const std::vector< AST_Field * > &fields, const string &key)
bool	is_bounded_type (AST_Type *type)
void	align (size_t alignment, size_t &size, size_t &padding)
void	max_marshaled_size (AST_Type *type, size_t &size, size_t &padding)
void	mms_repeating (AST_Type *type, size_t n, size_t &size, size_t &padding)
void	max_marshaled_size (AST_Type *type, size_t &size, size_t &padding)
string	findSizeCommon (const string &name, AST_Type *type, const string &prefix, string &intro, const string &="")
string	streamCommon (const string &name, AST_Type *type, const string &prefix, string &intro, const string &stru="")
bool	isRtpsSpecialStruct (const string &cxx)
bool	genRtpsSpecialStruct (const string &cxx)
bool	isRtpsSpecialUnion (const string &cxx)
bool	genRtpsParameter (AST_Type *discriminator, const std::vector< AST_UnionBranch * > &branches)
bool	genRtpsSubmessage (AST_Type *discriminator, const std::vector< AST_UnionBranch * > &branches)
bool	genRtpsSpecialUnion (const string &cxx, AST_Type *discriminator, const std::vector< AST_UnionBranch * > &branches)
Variables
std::map< string, string >	cst_
string	iQosOffset_
string	preamble_

---

Function Documentation

void @89::align	(	size_t	alignment,
		size_t &	size,
		size_t &	padding
	)			[static]

Definition at line 688 of file marshal_generator.cpp.

Referenced by findSizeCommon(), gen_array(), marshal_generator::gen_union(), and max_marshaled_size().

  {
    if ((size + padding) % alignment) {
      padding += alignment - ((size + padding) % alignment);
    }
  }

string @89::checkAlignment

(

AST_Type *

elem

)

[static]

Definition at line 133 of file marshal_generator.cpp.

Referenced by gen_sequence().

  {
    // At this point the stream must be 4-byte aligned (from the sequence
    // length), but it might need to be 8-byte aligned for primitives > 4.
    switch (AST_PredefinedType::narrow_from_decl(elem)->pt()) {
    case AST_PredefinedType::PT_longlong:
    case AST_PredefinedType::PT_ulonglong:
    case AST_PredefinedType::PT_double:
    case AST_PredefinedType::PT_longdouble:
      return
        "  if ((size + padding) % 8) {\n"
        "    padding += 4;\n"
        "  }\n";
    default:
      return "";
    }
  }

AST_Type* @89::find_type	(	const std::vector< AST_Field * > &	fields,
		const string &	key
	)			[static]

Definition at line 549 of file marshal_generator.cpp.

Referenced by marshal_generator::gen_struct().

  {
    string key_base = key;   // the field we are looking for here
    string key_rem;          // the sub-field we will look for recursively
    bool is_array = false;
    size_t pos = key.find_first_of(".[");
    if (pos != std::string::npos) {
      key_base = key.substr(0, pos);
      if (key[pos] == '[') {
        is_array = true;
        size_t l_brack = key.find("]");
        if (l_brack == std::string::npos) {
          throw std::string("Missing right bracket");
        } else if (l_brack != key.length()) {
          key_rem = key.substr(l_brack+1);
        }
      } else {
        key_rem = key.substr(pos+1);
      }
    }
    for (size_t i = 0; i < fields.size(); ++i) {
      string field_name = fields[i]->local_name()->get_string();
      if (field_name == key_base) {
        AST_Type* field_type = fields[i]->field_type();
        if (!is_array && key_rem.empty()) {
          // The requested key field matches this one.  We do not allow
          // arrays (must be indexed specifically) or structs (must
          // identify specific sub-fields).
          AST_Structure* sub_struct = dynamic_cast<AST_Structure*>(field_type);
          if (sub_struct != 0) {
            throw std::string("Structs not allowed as keys");
          }
          AST_Typedef* typedef_node = dynamic_cast<AST_Typedef*>(field_type);
          if (typedef_node != 0) {
            AST_Array* array_node =
              dynamic_cast<AST_Array*>(typedef_node->base_type());
            if (array_node != 0) {
              throw std::string("Arrays not allowed as keys");
            }
          }
          return field_type;
        } else if (is_array) {
          // must be a typedef of an array
          AST_Typedef* typedef_node = dynamic_cast<AST_Typedef*>(field_type);
          if (typedef_node == 0) {
            throw std::string("Indexing for non-array type");
          }
          AST_Array* array_node =
            dynamic_cast<AST_Array*>(typedef_node->base_type());
          if (array_node == 0) {
            throw std::string("Indexing for non-array type");
          }
          if (array_node->n_dims() > 1) {
            throw std::string("Only single dimension arrays allowed in keys");
          }
          if (key_rem == "") {
            return array_node->base_type();
          } else {
            // This must be a struct...
            if ((key_rem[0] != '.') || (key_rem.length() == 1)) {
              throw std::string("Unexpected characters after array index");
            } else {
              // Set up key_rem and field_type and let things fall into
              // the struct code below
              key_rem = key_rem.substr(1);
              field_type = array_node->base_type();
            }
          }
        }

        // nested structures
        AST_Structure* sub_struct = dynamic_cast<AST_Structure*>(field_type);
        if (sub_struct == 0) {
          throw std::string("Expected structure field for ") + key_base;
        }
        size_t nfields = sub_struct->nfields();
        std::vector<AST_Field*> sub_fields;
        sub_fields.reserve(nfields);

        for (unsigned long i = 0; i < nfields; ++i) {
          AST_Field** f;
          sub_struct->field(f, i);
          sub_fields.push_back(*f);
        }
        // find type of nested struct field
        return find_type(sub_fields, key_rem);
      }
    }
    throw std::string("Field not found.");
  }

string @90::findSizeCommon	(	const string &	name,
		AST_Type *	type,
		const string &	prefix,
		string &	intro,
		const string &	= ""
	)			[static]

Definition at line 852 of file marshal_generator.cpp.

References align(), AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_UNKNOWN, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), getAlignment(), getArrayForany(), getWrapper(), AstTypeClassification::resolveActualType(), scoped(), and WD_OUTPUT.

Referenced by marshal_generator::gen_struct(), marshal_generator::gen_union(), genRtpsParameter(), and genRtpsSubmessage().

  {
    AST_Type* typedeff = type;
    type = resolveActualType(type);
    Classification fld_cls = classify(type);
    const string qual = prefix + '.' + name;
    const string indent = (prefix == "uni") ? "      " : "  ";
    if (fld_cls & CL_ENUM) {
      return indent + "find_size_ulong(size, padding);\n";
    } else if (fld_cls & CL_STRING) {
      const string suffix = (prefix == "uni") ? "" : ".in()";
      return indent + "find_size_ulong(size, padding);\n" +
        indent + "size += ACE_OS::strlen(" + qual + suffix + ")"
        + ((fld_cls & CL_WIDE) ? " * OpenDDS::DCPS::Serializer::WCHAR_SIZE;\n"
                               : " + 1;\n");
    } else if (fld_cls & CL_PRIMITIVE) {
      string align = getAlignment(type);
      if (!align.empty()) {
        align =
          indent + "if ((size + padding) % " + align + ") {\n" +
          indent + "  padding += " + align + " - ((size + padding) % "
          + align + ");\n" +
          indent + "}\n";
      }
      return align +
        indent + "size += gen_max_marshaled_size(" +
        getWrapper(qual, type, WD_OUTPUT) + ");\n";
    } else if (fld_cls == CL_UNKNOWN) {
      return ""; // warning will be issued for the serialize functions
    } else { // sequence, struct, union, array
      string fieldref = prefix, local = name;
      if (fld_cls & CL_ARRAY) {
        intro += indent + getArrayForany(prefix.c_str(), name.c_str(),
                                         scoped(typedeff->name())) + '\n';
        fieldref += '_';
        if (local.size() > 2 && local.substr(local.size() - 2) == "()") {
          local.erase(local.size() - 2);
        }
      } else {
        fieldref += '.';
      }
      return indent +
        "gen_find_size(" + fieldref + local + ", size, padding);\n";
    }
  }

void @89::gen_array	(	UTL_ScopedName *	name,
		AST_Array *	arr
	)			[static]

Definition at line 409 of file marshal_generator.cpp.

References BE_GlobalData::add_include(), BE_GlobalData::add_referenced(), Function::addArg(), align(), be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), Function::endArgs(), getAlignment(), getMaxSizeExprPrimitive(), getSerializerName(), BE_GlobalData::impl_, NestedForLoops::index_, AstTypeClassification::resolveActualType(), scoped(), and streamAndCheck().

  {
    be_global->add_include("dds/DCPS/Serializer.h");
    NamespaceGuard ng;
    string cxx = scoped(name);
    AST_Type* elem = resolveActualType(arr->base_type());
    Classification elem_cls = classify(elem);
    if (!elem->in_main_file()
        && elem->node_type() != AST_Decl::NT_pre_defined) {
      be_global->add_referenced(elem->file_name().c_str());
    }
    string cxx_elem = scoped(elem->name());
    size_t n_elems = 1;
    for (size_t i = 0; i < arr->n_dims(); ++i) {
      n_elems *= arr->dims()[i]->ev()->u.ulval;
    }
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("arr", "const " + cxx + "_forany&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      if (elem_cls & CL_ENUM) {
        be_global->impl_ <<
          "  find_size_ulong(size, padding);\n";
          if (n_elems > 1) {
            be_global->impl_ <<
              "  size += " << n_elems - 1 << " * max_marshaled_size_ulong();\n";
          }
      } else if (elem_cls & CL_PRIMITIVE) {
        const string align = getAlignment(elem);
        if (!align.empty()) {
          be_global->impl_ <<
            "  if ((size + padding) % " << align << ") {\n"
            "    padding += " << align << " - ((size + padding) % " << align
            << ");\n"
            "  }\n";
        }
        be_global->impl_ <<
          "  size += " << n_elems << " * " << getMaxSizeExprPrimitive(elem)
          << ";\n";
      } else { // String, Struct, Array, Sequence, Union
        string indent = "  ";
        NestedForLoops nfl("CORBA::ULong", "i", arr, indent);
        if (elem_cls & CL_STRING) {
          be_global->impl_ <<
            indent << "find_size_ulong(size, padding);\n" <<
            indent << "size += ACE_OS::strlen(arr" << nfl.index_ << ".in())"
            << ((elem_cls & CL_WIDE)
                ? " * OpenDDS::DCPS::Serializer::WCHAR_SIZE;\n"
                : " + 1;\n");
        } else if (elem_cls & CL_ARRAY) {
          be_global->impl_ <<
            indent << cxx_elem << "_var tmp_var = " << cxx_elem
            << "_dup(arr" << nfl.index_ << ");\n" <<
            indent << cxx_elem << "_forany tmp = tmp_var.inout();\n" <<
            indent << "gen_find_size(tmp, size, padding);\n";
        } else { // Struct, Sequence, Union
          be_global->impl_ <<
            indent << "gen_find_size(arr" << nfl.index_
            << ", size, padding);\n";
        }
      }
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("arr", "const " + cxx + "_forany&");
      insertion.endArgs();
      if (elem_cls & CL_PRIMITIVE) {
        be_global->impl_ <<
          "  return strm.write_" << getSerializerName(elem)
          << "_array(arr.in(), " << n_elems << ");\n";
      } else { // Enum, String, Struct, Array, Sequence, Union
        {
          string indent = "  ";
          NestedForLoops nfl("CORBA::ULong", "i", arr, indent);
          if (elem_cls & CL_ARRAY) {
            be_global->impl_ <<
              indent << cxx_elem << "_var tmp_var = " << cxx_elem
              << "_dup(arr" << nfl.index_ << ");\n" <<
              indent << cxx_elem << "_forany tmp = tmp_var.inout();\n" <<
              streamAndCheck("<< tmp", indent.size());
          } else {
            string suffix = (elem_cls & CL_STRING) ? ".in()" : "";
            be_global->impl_ <<
              streamAndCheck("<< arr" + nfl.index_ + suffix , indent.size());
          }
        }
        be_global->impl_ << "  return true;\n";
      }
    }
    {
      Function extraction("operator>>", "bool");
      extraction.addArg("strm", "Serializer&");
      extraction.addArg("arr", cxx + "_forany&");
      extraction.endArgs();
      if (elem_cls & CL_PRIMITIVE) {
        be_global->impl_ <<
          "  return strm.read_" << getSerializerName(elem)
          << "_array(arr.out(), " << n_elems << ");\n";
      } else { // Enum, String, Struct, Array, Sequence, Union
        {
          string indent = "  ";
          NestedForLoops nfl("CORBA::ULong", "i", arr, indent);
          if (elem_cls & CL_ARRAY) {
            const string typedefname = scoped(arr->base_type()->name());
            be_global->impl_ <<
              indent << typedefname << "_var tmp = " << typedefname
              << "_alloc();\n" <<
              indent << typedefname << "_forany fa = tmp.inout();\n"
              << streamAndCheck(">> fa", indent.size()) <<
              indent << typedefname << "_copy(arr" << nfl.index_ <<
              ", tmp.in());\n";
          } else {
            string suffix = (elem_cls & CL_STRING) ? ".out()" : "";
            be_global->impl_ <<
              streamAndCheck(">> arr" + nfl.index_ + suffix, indent.size());
          }
        }
        be_global->impl_ << "  return true;\n";
      }
    }
  }

void @89::gen_sequence	(	UTL_ScopedName *	tdname,
		AST_Sequence *	seq
	)			[static]

Definition at line 212 of file marshal_generator.cpp.

References BE_GlobalData::add_include(), BE_GlobalData::add_referenced(), Function::addArg(), be_global, checkAlignment(), AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_BOUNDED, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_INTERFACE, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_UNKNOWN, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), Function::endArgs(), genRtpsSpecialSequence(), getMaxSizeExprPrimitive(), getSerializerName(), getWrapper(), BE_GlobalData::impl_, isRtpsSpecialSequence(), BE_GlobalData::LANGMAP_FACE_CXX, BE_GlobalData::LANGMAP_NONE, BE_GlobalData::LANGMAP_SP_CXX, BE_GlobalData::language_mapping(), nameOfSeqHeader(), AstTypeClassification::resolveActualType(), scoped(), BE_GlobalData::STREAM_CPP, streamAndCheck(), and WD_INPUT.

Referenced by marshal_generator::gen_typedef().

  {
    be_global->add_include("dds/DCPS/Serializer.h");
    NamespaceGuard ng;
    string cxx = scoped(tdname);
    if (isRtpsSpecialSequence(cxx)) {
      genRtpsSpecialSequence(cxx);
      return;
    }
    AST_Type* elem = resolveActualType(seq->base_type());
    Classification elem_cls = classify(elem);
    if (!elem->in_main_file()) {
      if (elem->node_type() == AST_Decl::NT_pre_defined) {
        if (be_global->language_mapping() != BE_GlobalData::LANGMAP_FACE_CXX &&
            be_global->language_mapping() != BE_GlobalData::LANGMAP_SP_CXX) {
          be_global->add_include(("dds/CorbaSeq/" + nameOfSeqHeader(elem)
                                  + "SeqTypeSupportImpl.h").c_str(), BE_GlobalData::STREAM_CPP);
        }
      } else {
        be_global->add_referenced(elem->file_name().c_str());
      }
    }
    string cxx_elem = scoped(elem->name());
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("seq", "const " + cxx + "&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      be_global->impl_ <<
        "  find_size_ulong(size, padding);\n"
        "  if (seq.length() == 0) {\n"
        "    return;\n"
        "  }\n";
      if (elem_cls & CL_ENUM) {
        be_global->impl_ <<
          "  size += seq.length() * max_marshaled_size_ulong();\n";
      } else if (elem_cls & CL_PRIMITIVE) {
        be_global->impl_ << checkAlignment(elem) <<
          "  size += seq.length() * " << getMaxSizeExprPrimitive(elem) << ";\n";
      } else if (elem_cls & CL_INTERFACE) {
        be_global->impl_ <<
          "  // sequence of objrefs is not marshaled\n";
      } else if (elem_cls == CL_UNKNOWN) {
        be_global->impl_ <<
          "  // sequence of unknown/unsupported type\n";
      } else { // String, Struct, Array, Sequence, Union
        be_global->impl_ <<
          "  for (CORBA::ULong i = 0; i < seq.length(); ++i) {\n";
        if (elem_cls & CL_STRING) {
          be_global->impl_ <<
            "    find_size_ulong(size, padding);\n"
            "    if (seq[i]) {\n"
            "      size += ACE_OS::strlen(seq[i])"
            << ((elem_cls & CL_WIDE)
                ? " * OpenDDS::DCPS::Serializer::WCHAR_SIZE;\n"
                : " + 1;\n") <<
            "    }\n";
        } else if (elem_cls & CL_ARRAY) {
          be_global->impl_ <<
            "    " << cxx_elem << "_var tmp_var = " << cxx_elem
            << "_dup(seq[i]);\n"
            "    " << cxx_elem << "_forany tmp = tmp_var.inout();\n"
            "    gen_find_size(tmp, size, padding);\n";
        } else { // Struct, Sequence, Union
          be_global->impl_ <<
            "    gen_find_size(seq[i], size, padding);\n";
        }
        be_global->impl_ <<
          "  }\n";
      }
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("seq", "const " + cxx + "&");
      insertion.endArgs();
      be_global->impl_ <<
        "  const CORBA::ULong length = seq.length();\n"
        << streamAndCheck("<< length") <<
        "  if (length == 0) {\n"
        "    return true;\n"
        "  }\n";
      if (elem_cls & CL_PRIMITIVE) {
        be_global->impl_ <<
          "  return strm.write_" << getSerializerName(elem)
          << "_array(seq.get_buffer(), length);\n";
      } else if (elem_cls & CL_INTERFACE) {
        be_global->impl_ <<
          "  return false; // sequence of objrefs is not marshaled\n";
      } else if (elem_cls == CL_UNKNOWN) {
        be_global->impl_ <<
          "  return false; // sequence of unknown/unsupported type\n";
      } else { // Enum, String, Struct, Array, Sequence, Union
        be_global->impl_ <<
          "  for (CORBA::ULong i = 0; i < length; ++i) {\n";
        if (elem_cls & CL_ARRAY) {
          const string typedefname = scoped(seq->base_type()->name());
          be_global->impl_ <<
            "    " << typedefname << "_var tmp_var = " << typedefname
            << "_dup(seq[i]);\n"
            "    " << typedefname << "_forany tmp = tmp_var.inout();\n"
            << streamAndCheck("<< tmp", 4);
        } else {
          be_global->impl_ << streamAndCheck("<< seq[i]", 4);
        }
        be_global->impl_ <<
          "  }\n"
          "  return true;\n";
      }
    }
    {
      Function extraction("operator>>", "bool");
      extraction.addArg("strm", "Serializer&");
      extraction.addArg("seq", cxx + "&");
      extraction.endArgs();
      be_global->impl_ <<
        "  CORBA::ULong length;\n"
        << streamAndCheck(">> length");
      if (!seq->unbounded()) {
        be_global->impl_ <<
          "  if (length > seq.maximum()) {\n"
          "    return false;\n"
          "  }\n";
      }
      be_global->impl_ <<
        "  seq.length(length);\n";
      if (elem_cls & CL_PRIMITIVE) {
        be_global->impl_ <<
          "  if (length == 0) {\n"
          "    return true;\n"
          "  }\n"
          "  return strm.read_" << getSerializerName(elem)
          << "_array(seq.get_buffer(), length);\n";
      } else if (elem_cls & CL_INTERFACE) {
        be_global->impl_ <<
          "  return false; // sequence of objrefs is not marshaled\n";
      } else if (elem_cls == CL_UNKNOWN) {
        be_global->impl_ <<
          "  return false; // sequence of unknown/unsupported type\n";
      } else { // Enum, String, Struct, Array, Sequence, Union
        be_global->impl_ <<
          "  for (CORBA::ULong i = 0; i < length; ++i) {\n";
        if (elem_cls & CL_ARRAY) {
          const string typedefname = scoped(seq->base_type()->name());
          be_global->impl_ <<
            "    " << typedefname << "_var tmp = " << typedefname
            << "_alloc();\n"
            "    " << typedefname << "_forany fa = tmp.inout();\n"
            << streamAndCheck(">> fa", 4) <<
            "    " << typedefname << "_copy(seq[i], tmp.in());\n";
        } else if (elem_cls & CL_STRING) {
          if (elem_cls & CL_BOUNDED) {
            AST_String* str = AST_String::narrow_from_decl(elem);
            std::ostringstream args;
            args << "seq[i].out(), " << str->max_size()->ev()->u.ulval;
            be_global->impl_ <<
              streamAndCheck(">> " + getWrapper(args.str(), elem, WD_INPUT), 4);
          } else { // unbounded string
            const string getbuffer =
              (be_global->language_mapping() == BE_GlobalData::LANGMAP_NONE)
              ? ".get_buffer()" : "";
            be_global->impl_ << streamAndCheck(">> seq" + getbuffer + "[i]", 4);
          }
        } else { // Enum, Struct, Sequence, Union
          be_global->impl_ << streamAndCheck(">> seq[i]", 4);
        }
        be_global->impl_ <<
          "  }\n"
          "  return true;\n";
      }
    }
  }

bool @91::genRtpsParameter	(	AST_Type *	discriminator,
		const std::vector< AST_UnionBranch * > &	branches
	)			[static]

Definition at line 1331 of file marshal_generator.cpp.

References Function::addArg(), be_global, Function::endArgs(), findSizeCommon(), generateSwitchBodyForUnion(), generateSwitchForUnion(), BE_GlobalData::impl_, and streamCommon().

Referenced by genRtpsSpecialUnion().

  {
    const string cxx = "OpenDDS::RTPS::Parameter";
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("uni", "const " + cxx + "&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      generateSwitchForUnion("uni._d()", findSizeCommon, branches, discriminator,
                                 "", "", cxx);
      be_global->impl_ <<
        "  size += 4; // parameterId & length\n";
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("outer_strm", "Serializer&");
      insertion.addArg("uni", "const " + cxx + "&");
      insertion.endArgs();
      be_global->impl_ <<
        "  if (!(outer_strm << uni._d())) {\n"
        "    return false;\n"
        "  }\n"
        "  size_t size = 0, pad = 0;\n"
        "  gen_find_size(uni, size, pad);\n"
        "  size -= 4; // parameterId & length\n"
        "  const size_t post_pad = 4 - ((size + pad) % 4);\n"
        "  const size_t total = size + pad + ((post_pad < 4) ? post_pad : 0);\n"
        "  if (size + pad > ACE_UINT16_MAX || "
        "!(outer_strm << ACE_CDR::UShort(total))) {\n"
        "    return false;\n"
        "  }\n"
        "  ACE_Message_Block param(size + pad);\n"
        "  Serializer strm(&param, outer_strm.swap_bytes(), "
        "outer_strm.alignment());\n"
        "  if (!insertParamData(strm, uni)) {\n"
        "    return false;\n"
        "  }\n"
        "  const ACE_CDR::Octet* data = reinterpret_cast<ACE_CDR::Octet*>("
        "param.rd_ptr());\n"
        "  if (!outer_strm.write_octet_array(data, ACE_CDR::ULong(param.length()))) {\n"
        "    return false;\n"
        "  }\n"
        "  if (post_pad < 4 && outer_strm.alignment() != "
        "Serializer::ALIGN_NONE) {\n"
        "    static const ACE_CDR::Octet padding[3] = {0};\n"
        "    return outer_strm.write_octet_array(padding, "
        "ACE_CDR::ULong(post_pad));\n"
        "  }\n"
        "  return true;\n";
    }
    {
      Function insertData("insertParamData", "bool");
      insertData.addArg("strm", "Serializer&");
      insertData.addArg("uni", "const " + cxx + "&");
      insertData.endArgs();
      generateSwitchForUnion("uni._d()", streamCommon, branches, discriminator,
                                 "return", "<< ", cxx);
    }
    {
      Function extraction("operator>>", "bool");
      extraction.addArg("outer_strm", "Serializer&");
      extraction.addArg("uni", cxx + "&");
      extraction.endArgs();
      be_global->impl_ <<
        "  ACE_CDR::UShort disc, size;\n"
        "  if (!(outer_strm >> disc) || !(outer_strm >> size)) {\n"
        "    return false;\n"
        "  }\n"
        "  if (disc == OpenDDS::RTPS::PID_SENTINEL) {\n"
        "    uni._d(OpenDDS::RTPS::PID_SENTINEL);\n"
        "    return true;\n"
        "  }\n"
        "  ACE_Message_Block param(size);\n"
        "  ACE_CDR::Octet* data = reinterpret_cast<ACE_CDR::Octet*>("
        "param.wr_ptr());\n"
        "  if (!outer_strm.read_octet_array(data, size)) {\n"
        "    return false;\n"
        "  }\n"
        "  param.wr_ptr(size);\n"
        "  Serializer strm(&param, outer_strm.swap_bytes(), "
        "Serializer::ALIGN_CDR);\n"
        "  switch (disc) {\n";
      generateSwitchBodyForUnion(streamCommon, branches, discriminator,
                                 "return", ">> ", cxx, true);
      be_global->impl_ <<
        "  default:\n"
        "    {\n"
        "      uni.unknown_data(DDS::OctetSeq(size));\n"
        "      uni.unknown_data().length(size);\n"
        "      std::memcpy(uni.unknown_data().get_buffer(), data, size);\n"
        "      uni._d(disc);\n"
        "    }\n"
        "  }\n"
        "  return true;\n";
    }
    return true;
  }

bool @89::genRtpsSpecialSequence

(

const string &

cxx

)

[static]

Definition at line 156 of file marshal_generator.cpp.

References Function::addArg(), be_global, Function::endArgs(), and BE_GlobalData::impl_.

Referenced by gen_sequence().

  {
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("seq", "const " + cxx + "&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      be_global->impl_ <<
        "  for (CORBA::ULong i = 0; i < seq.length(); ++i) {\n"
        "    if (seq[i]._d() == OpenDDS::RTPS::PID_SENTINEL) continue;\n"
        "    size_t param_size = 0, param_padding = 0;\n"
        "    gen_find_size(seq[i], param_size, param_padding);\n"
        "    size += param_size + param_padding;\n"
        "    if (size % 4) {\n"
        "      size += 4 - (size % 4);\n"
        "    }\n"
        "  }\n"
        "  size += 4; /* PID_SENTINEL */\n";
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("seq", "const " + cxx + "&");
      insertion.endArgs();
      be_global->impl_ <<
        "  for (CORBA::ULong i = 0; i < seq.length(); ++i) {\n"
        "    if (seq[i]._d() == OpenDDS::RTPS::PID_SENTINEL) continue;\n"
        "    if (!(strm << seq[i])) {\n"
        "      return false;\n"
        "    }\n"
        "  }\n"
        "  return (strm << OpenDDS::RTPS::PID_SENTINEL)\n"
        "    && (strm << OpenDDS::RTPS::PID_PAD);\n";
    }
    {
      Function extraction("operator>>", "bool");
      extraction.addArg("strm", "Serializer&");
      extraction.addArg("seq", cxx + "&");
      extraction.endArgs();
      be_global->impl_ <<
        "  while (true) {\n"
        "    const CORBA::ULong len = seq.length();\n"
        "    seq.length(len + 1);\n"
        "    if (!(strm >> seq[len])) {\n"
        "      return false;\n"
        "    }\n"
        "    if (seq[len]._d() == OpenDDS::RTPS::PID_SENTINEL) {\n"
        "      seq.length(len);\n"
        "      return true;\n"
        "    }\n"
        "  }\n";
    }
    return true;
  }

bool @90::genRtpsSpecialStruct

(

const string &

cxx

)

[static]

Definition at line 951 of file marshal_generator.cpp.

References Function::addArg(), be_global, Function::endArgs(), and BE_GlobalData::impl_.

Referenced by marshal_generator::gen_struct().

  {
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("stru", "const " + cxx + "&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      be_global->impl_ <<
        "  size += "
        << ((cxx == "OpenDDS::RTPS::SequenceNumberSet") ? "12" : "8")
        << " + 4 * ((stru.numBits + 31) / 32); // RTPS Custom\n";
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("stru", "const " + cxx + "&");
      insertion.endArgs();
      be_global->impl_ <<
        "  if ((strm << stru.bitmapBase) && (strm << stru.numBits)) {\n"
        "    const CORBA::ULong M = (stru.numBits + 31) / 32;\n"
        "    if (stru.bitmap.length() < M) {\n"
        "      return false;\n"
        "    }\n"
        "    for (CORBA::ULong i = 0; i < M; ++i) {\n"
        "      if (!(strm << stru.bitmap[i])) {\n"
        "        return false;\n"
        "      }\n"
        "    }\n"
        "    return true;\n"
        "  }\n"
        "  return false;\n";
    }
    {
      Function extraction("operator>>", "bool");
      extraction.addArg("strm", "Serializer&");
      extraction.addArg("stru", cxx + "&");
      extraction.endArgs();
      be_global->impl_ <<
        "  if ((strm >> stru.bitmapBase) && (strm >> stru.numBits)) {\n"
        "    const CORBA::ULong M = (stru.numBits + 31) / 32;\n"
        "    if (M > 8) {\n"
        "      return false;\n"
        "    }\n"
        "    stru.bitmap.length(M);\n"
        "    for (CORBA::ULong i = 0; i < M; ++i) {\n"
        "      if (!(strm >> stru.bitmap[i])) {\n"
        "        return false;\n"
        "      }\n"
        "    }\n"
        "    return true;\n"
        "  }\n"
        "  return false;\n";
    }
    return true;
  }

bool @91::genRtpsSpecialUnion	(	const string &	cxx,
		AST_Type *	discriminator,
		const std::vector< AST_UnionBranch * > &	branches
	)			[static]

Definition at line 1462 of file marshal_generator.cpp.

References genRtpsParameter(), and genRtpsSubmessage().

Referenced by marshal_generator::gen_union().

  {
    if (cxx == "OpenDDS::RTPS::Parameter") {
      return genRtpsParameter(discriminator, branches);
    } else if (cxx == "OpenDDS::RTPS::Submessage") {
      return genRtpsSubmessage(discriminator, branches);
    } else {
      return false;
    }
  }

bool @91::genRtpsSubmessage	(	AST_Type *	discriminator,
		const std::vector< AST_UnionBranch * > &	branches
	)			[static]

Definition at line 1431 of file marshal_generator.cpp.

References Function::addArg(), be_global, Function::endArgs(), findSizeCommon(), generateSwitchForUnion(), BE_GlobalData::impl_, and streamCommon().

Referenced by genRtpsSpecialUnion().

  {
    const string cxx = "OpenDDS::RTPS::Submessage";
    {
      Function find_size("gen_find_size", "void");
      find_size.addArg("uni", "const " + cxx + "&");
      find_size.addArg("size", "size_t&");
      find_size.addArg("padding", "size_t&");
      find_size.endArgs();
      generateSwitchForUnion("uni._d()", findSizeCommon, branches, discriminator,
                                 "", "", cxx);
    }
    {
      Function insertion("operator<<", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("uni", "const " + cxx + "&");
      insertion.endArgs();
      generateSwitchForUnion("uni._d()", streamCommon, branches, discriminator,
                                 "return", "<< ", cxx);
    }
    {
      Function insertion("operator>>", "bool");
      insertion.addArg("strm", "Serializer&");
      insertion.addArg("uni", cxx + "&");
      insertion.endArgs();
      be_global->impl_ << "  // unused\n  return false;\n";
    }
    return true;
  }

string @89::getAlignment

(

AST_Type *

elem

)

[static]

Definition at line 386 of file marshal_generator.cpp.

Referenced by findSizeCommon(), gen_array(), and marshal_generator::gen_union().

  {
    if (elem->node_type() == AST_Decl::NT_enum) {
      return "4";
    }
    switch (AST_PredefinedType::narrow_from_decl(elem)->pt()) {
    case AST_PredefinedType::PT_short:
    case AST_PredefinedType::PT_ushort:
      return "2";
    case AST_PredefinedType::PT_long:
    case AST_PredefinedType::PT_ulong:
    case AST_PredefinedType::PT_float:
      return "4";
    case AST_PredefinedType::PT_longlong:
    case AST_PredefinedType::PT_ulonglong:
    case AST_PredefinedType::PT_double:
    case AST_PredefinedType::PT_longdouble:
      return "8";
    default:
      return "";
    }
  }

string @89::getArrayForany	(	const char *	prefix,
		const char *	fname,
		const string &	cxx_fld
	)			[static]

Definition at line 534 of file marshal_generator.cpp.

Referenced by findSizeCommon(), and streamCommon().

  {
    string local = fname;
    if (local.size() > 2 && local.substr(local.size() - 2, 2) == "()") {
      local.erase(local.size() - 2);
    }
    return cxx_fld + "_forany " + prefix + '_' + local + "(const_cast<"
      + cxx_fld + "_slice*>(" + prefix + "." + fname + "));";
  }

string @89::getMaxSizeExprPrimitive

(

AST_Type *

type

)

[static]

Definition at line 54 of file marshal_generator.cpp.

References scoped().

Referenced by gen_array(), and gen_sequence().

  {
    if (type->node_type() != AST_Decl::NT_pre_defined) {
      return "";
    }
    AST_PredefinedType* pt = AST_PredefinedType::narrow_from_decl(type);
    switch (pt->pt()) {
    case AST_PredefinedType::PT_octet:
      return "max_marshaled_size_octet()";
    case AST_PredefinedType::PT_char:
      return "max_marshaled_size_char()";
    case AST_PredefinedType::PT_wchar:
      return "max_marshaled_size_wchar()";
    case AST_PredefinedType::PT_boolean:
      return "max_marshaled_size_boolean()";
    default:
      return "gen_max_marshaled_size(" + scoped(type->name()) + "())";
    }
  }

string @89::getSerializerName

(

AST_Type *

type

)

[static]

Definition at line 74 of file marshal_generator.cpp.

Referenced by gen_array(), gen_sequence(), and nameOfSeqHeader().

  {
    switch (AST_PredefinedType::narrow_from_decl(type)->pt()) {
    case AST_PredefinedType::PT_long:
      return "long";
    case AST_PredefinedType::PT_ulong:
      return "ulong";
    case AST_PredefinedType::PT_short:
      return "short";
    case AST_PredefinedType::PT_ushort:
      return "ushort";
    case AST_PredefinedType::PT_octet:
      return "octet";
    case AST_PredefinedType::PT_char:
      return "char";
    case AST_PredefinedType::PT_wchar:
      return "wchar";
    case AST_PredefinedType::PT_float:
      return "float";
    case AST_PredefinedType::PT_double:
      return "double";
    case AST_PredefinedType::PT_longlong:
      return "longlong";
    case AST_PredefinedType::PT_ulonglong:
      return "ulonglong";
    case AST_PredefinedType::PT_longdouble:
      return "longdouble";
    case AST_PredefinedType::PT_boolean:
      return "boolean";
    default:
      return "";
    }
  }

bool @89::is_bounded_type

(

AST_Type *

type

)

[static]

Definition at line 640 of file marshal_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_BOUNDED, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

Referenced by marshal_generator::gen_struct().

  {
    bool bounded = true;
    static std::vector<AST_Type*> type_stack;
    type = resolveActualType(type);
    for (unsigned int i = 0; i < type_stack.size(); i++) {
      // If we encounter the same type recursively, then we are unbounded
      if (type == type_stack[i]) return false;
    }
    type_stack.push_back(type);
    Classification fld_cls = classify(type);
    if ((fld_cls & CL_STRING) && !(fld_cls & CL_BOUNDED)) {
      bounded = false;
    } else if (fld_cls & CL_STRUCTURE) {
      AST_Structure* struct_node = dynamic_cast<AST_Structure*>(type);
      for (unsigned long i = 0; i < struct_node->nfields(); ++i) {
        AST_Field** f;
        struct_node->field(f, i);
        if (!is_bounded_type((*f)->field_type())) {
          bounded = false;
          break;
        }
      }
    } else if (fld_cls & CL_SEQUENCE) {
      if (fld_cls & CL_BOUNDED) {
        AST_Sequence* seq_node = dynamic_cast<AST_Sequence*>(type);
        if (!is_bounded_type(seq_node->base_type())) bounded = false;
      } else {
        bounded = false;
      }
    } else if (fld_cls & CL_ARRAY) {
      AST_Array* array_node = dynamic_cast<AST_Array*>(type);
      if (!is_bounded_type(array_node->base_type())) bounded = false;
    } else if (fld_cls & CL_UNION) {
      AST_Union* union_node = dynamic_cast<AST_Union*>(type);
      for (unsigned long i = 0; i < union_node->nfields(); ++i) {
        AST_Field** f;
        union_node->field(f, i);
        if (!is_bounded_type((*f)->field_type())) {
          bounded = false;
          break;
        }
      }
    }
    type_stack.pop_back();
    return bounded;
  }

bool @89::isRtpsSpecialSequence

(

const string &

cxx

)

[static]

Definition at line 151 of file marshal_generator.cpp.

Referenced by gen_sequence().

  {
    return cxx == "OpenDDS::RTPS::ParameterList";
  }

bool @90::isRtpsSpecialStruct

(

const string &

cxx

)

[static]

Definition at line 945 of file marshal_generator.cpp.

Referenced by marshal_generator::gen_struct().

  {
    return cxx == "OpenDDS::RTPS::SequenceNumberSet"
      || cxx == "OpenDDS::RTPS::FragmentNumberSet";
  }

bool @91::isRtpsSpecialUnion

(

const string &

cxx

)

[static]

Definition at line 1325 of file marshal_generator.cpp.

Referenced by marshal_generator::gen_union().

  {
    return cxx == "OpenDDS::RTPS::Parameter"
      || cxx == "OpenDDS::RTPS::Submessage";
  }

void @89::max_marshaled_size	(	AST_Type *	type,
		size_t &	size,
		size_t &	padding
	)			[static]

Definition at line 715 of file marshal_generator.cpp.

References align(), max_marshaled_size(), mms_repeating(), and AstTypeClassification::resolveActualType().

  {
    type = resolveActualType(type);
    switch (type->node_type()) {
    case AST_Decl::NT_pre_defined: {
        AST_PredefinedType* p = AST_PredefinedType::narrow_from_decl(type);
        switch (p->pt()) {
        case AST_PredefinedType::PT_char:
        case AST_PredefinedType::PT_boolean:
        case AST_PredefinedType::PT_octet:
          size += 1;
          break;
        case AST_PredefinedType::PT_short:
        case AST_PredefinedType::PT_ushort:
          align(2, size, padding);
          size += 2;
          break;
        case AST_PredefinedType::PT_wchar:
          size += 3; // see Serializer::max_marshaled_size_wchar()
          break;
        case AST_PredefinedType::PT_long:
        case AST_PredefinedType::PT_ulong:
        case AST_PredefinedType::PT_float:
          align(4, size, padding);
          size += 4;
          break;
        case AST_PredefinedType::PT_longlong:
        case AST_PredefinedType::PT_ulonglong:
        case AST_PredefinedType::PT_double:
          align(8, size, padding);
          size += 8;
          break;
        case AST_PredefinedType::PT_longdouble:
          align(8, size, padding);
          size += 16;
          break;
        default:
          // Anything else shouldn't be in a DDS type or is unbounded.
          break;
        }
        break;
      }
    case AST_Decl::NT_enum:
      align(4, size, padding);
      size += 4;
      break;
    case AST_Decl::NT_string:
    case AST_Decl::NT_wstring: {
        AST_String* string_node = dynamic_cast<AST_String*>(type);
        align(4, size, padding);
        size += 4;
        const int width = (string_node->width() == 1) ? 1 : 2 /*UTF-16*/;
        size += width * string_node->max_size()->ev()->u.ulval;
        if (type->node_type() == AST_Decl::NT_string) {
          size += 1; // narrow string includes the null terminator
        }
        break;
      }
    case AST_Decl::NT_struct: {
        AST_Structure* struct_node = dynamic_cast<AST_Structure*>(type);
        for (unsigned long i = 0; i < struct_node->nfields(); ++i) {
          AST_Field** f;
          struct_node->field(f, i);
          AST_Type* field_type = (*f)->field_type();
          max_marshaled_size(field_type, size, padding);
        }
        break;
      }
    case AST_Decl::NT_sequence: {
        AST_Sequence* seq_node = dynamic_cast<AST_Sequence*>(type);
        AST_Type* base_node = seq_node->base_type();
        size_t bound = seq_node->max_size()->ev()->u.ulval;
        align(4, size, padding);
        size += 4;
        mms_repeating(base_node, bound, size, padding);
        break;
      }
    case AST_Decl::NT_array: {
        AST_Array* array_node = dynamic_cast<AST_Array*>(type);
        AST_Type* base_node = array_node->base_type();
        size_t array_size = 1;
        AST_Expression** dims = array_node->dims();
        for (unsigned long i = 0; i < array_node->n_dims(); i++) {
          array_size *= dims[i]->ev()->u.ulval;
        }
        mms_repeating(base_node, array_size, size, padding);
        break;
      }
    case AST_Decl::NT_union: {
        AST_Union* union_node = dynamic_cast<AST_Union*>(type);
        max_marshaled_size(union_node->disc_type(), size, padding);
        size_t largest_field_size = 0, largest_field_pad = 0;
        const size_t starting_size = size, starting_pad = padding;
        for (unsigned long i = 0; i < union_node->nfields(); ++i) {
          AST_Field** f;
          union_node->field(f, i);
          AST_Type* field_type = (*f)->field_type();
          max_marshaled_size(field_type, size, padding);
          size_t field_size = size - starting_size,
            field_pad = padding - starting_pad;
          if (field_size > largest_field_size) {
            largest_field_size = field_size;
            largest_field_pad = field_pad;
          }
          // rewind:
          size = starting_size;
          padding = starting_pad;
        }
        size += largest_field_size;
        padding += largest_field_pad;
        break;
      }
    default:
      // Anything else should be not here or is unbounded
      break;
    }
  }

void @89::max_marshaled_size	(	AST_Type *	type,
		size_t &	size,
		size_t &	padding
	)			[static]

Referenced by OpenDDS::DCPS::ReplayerImpl::create_sample_data_message(), OpenDDS::DCPS::DataWriterImpl::create_sample_data_message(), OpenDDS::DCPS::DataWriterImpl::end_coherent_changes(), marshal_generator::gen_struct(), OpenDDS::DCPS::TransportReceiveStrategy< TH, DSH >::handle_dds_input(), max_marshaled_size(), mms_repeating(), OpenDDS::DCPS::TcpDataLink::send_graceful_disconnect_message(), and OpenDDS::DCPS::TransportSendStrategy::TransportSendStrategy().

void @89::mms_repeating	(	AST_Type *	type,
		size_t	n,
		size_t &	size,
		size_t &	padding
	)			[static]

Definition at line 699 of file marshal_generator.cpp.

References max_marshaled_size().

Referenced by max_marshaled_size().

  {
    if (n > 0) {
      // 1st element may need padding relative to whatever came before
      max_marshaled_size(type, size, padding);
    }
    if (n > 1) {
      // subsequent elements may need padding relative to prior element
      size_t prev_size = size, prev_pad = padding;
      max_marshaled_size(type, size, padding);
      size += (n - 2) * (size - prev_size);
      padding += (n - 2) * (padding - prev_pad);
    }
  }

string @89::nameOfSeqHeader

(

AST_Type *

elem

)

[static]

Definition at line 108 of file marshal_generator.cpp.

References getSerializerName().

Referenced by gen_sequence().

  {
    string ser = getSerializerName(elem);
    if (ser.size()) {
      ser[0] = static_cast<char>(std::toupper(ser[0]));
    }
    if (ser[0] == 'U' || ser[0] == 'W') {
      ser[1] = static_cast<char>(std::toupper(ser[1]));
    }
    const size_t fourthLast = ser.size() - 4;
    if (ser.size() > 7 && ser.substr(fourthLast) == "long") {
      ser[fourthLast] = static_cast<char>(std::toupper(ser[fourthLast]));
    }
    if (ser == "Longdouble") return "LongDouble";
    return ser;
  }

string @89::streamAndCheck	(	const string &	expr,
		size_t	indent = 2
	)			[static]

Definition at line 125 of file marshal_generator.cpp.

Referenced by gen_array(), gen_sequence(), and marshal_generator::gen_union().

  {
    string idt(indent, ' ');
    return idt + "if (!(strm " + expr + ")) {\n" +
      idt + "  return false;\n" +
      idt + "}\n";
  }

string @90::streamCommon	(	const string &	name,
		AST_Type *	type,
		const string &	prefix,
		string &	intro,
		const string &	stru = ""
	)			[static]

Definition at line 901 of file marshal_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_UNKNOWN, AstTypeClassification::classify(), getArrayForany(), getWrapper(), AstTypeClassification::resolveActualType(), scoped(), WD_INPUT, and WD_OUTPUT.

Referenced by marshal_generator::gen_struct(), marshal_generator::gen_union(), genRtpsParameter(), and genRtpsSubmessage().

  {
    AST_Type* typedeff = type;
    type = resolveActualType(type);
    Classification fld_cls = classify(type);
    const string qual = prefix + '.' + name, shift = prefix.substr(0, 2);
    WrapDirection dir = (shift == ">>") ? WD_INPUT : WD_OUTPUT;
    if ((fld_cls & CL_STRING) && (dir == WD_INPUT)) {
      return "(strm " + qual + ".out())";
    } else if (fld_cls & CL_PRIMITIVE) {
      return "(strm " + shift + ' '
        + getWrapper(qual.substr(3), type, dir) + ')';
    } else if (fld_cls == CL_UNKNOWN) {
      if (dir == WD_INPUT) { // no need to warn twice
        std::cerr << "WARNING: field " << name << " can not be serialized.  "
          "The struct or union it belongs to (" << stru <<
          ") can not be used in an OpenDDS topic type." << std::endl;
      }
      return "false";
    } else { // sequence, struct, union, array, enum, string(insertion)
      string fieldref = prefix, local = name;
      const bool accessor =
        local.size() > 2 && local.substr(local.size() - 2) == "()";
      if (fld_cls & CL_ARRAY) {
        string pre = prefix;
        if (shift == ">>" || shift == "<<") {
          pre.erase(0, 3);
        }
        if (accessor) {
          local.erase(local.size() - 2);
        }
        intro += "  " + getArrayForany(pre.c_str(), name.c_str(),
          scoped(typedeff->name())) + '\n';
        fieldref += '_';
      } else {
        fieldref += '.';
      }
      if ((fld_cls & CL_STRING) && !accessor) local += ".in()";
      return "(strm " + fieldref + local + ')';
    }
  }

---

Variable Documentation

std::map<string, string> cst_

Definition at line 1056 of file marshal_generator.cpp.

string iQosOffset_

Definition at line 1057 of file marshal_generator.cpp.

string preamble_

Definition at line 1057 of file marshal_generator.cpp.

---