#include <marshal_generator.h>

Inheritance diagram for marshal_generator:

Collaboration diagram for marshal_generator:

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

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

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

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

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

virtual bool	do_included_files () const

virtual void	gen_prologue ()

virtual void	gen_epilogue ()

virtual bool	gen_const (UTL_ScopedName , bool, AST_Constant )

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

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

virtual bool	gen_interf_fwd (UTL_ScopedName *)

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

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

Static Public Member Functions
static void	generate_dheader_code (const std::string &code, bool dheader_required, bool is_ser_func=true)

static void	gen_field_getValueFromSerialized (AST_Structure *node, const std::string &clazz)

Static Public Member Functions inherited from dds_generator
static std::string	get_tag_name (const std::string &base_name, bool nested_key_only=false)

static std::string	get_xtag_name (UTL_ScopedName *name)

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

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

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

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

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

Private Member Functions
void	gen_union_default (AST_UnionBranch *branch, const std::string &varname)

Detailed Description

Definition at line 13 of file marshal_generator.h.

Member Function Documentation

◆ gen_enum()

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

virtual

Reimplemented from dds_generator.

Definition at line 164 of file marshal_generator.cpp.

 {
   NamespaceGuard ng;
   be_global->add_include("dds/DCPS/Serializer.h");
   string cxx = scoped(name); // name as a C++ class
   {
     Function insertion("operator<<", "bool");
     insertion.addArg("strm", "Serializer&");
     insertion.addArg("enumval", "const " + cxx + "&");
     insertion.endArgs();
     const std::string idl_name = canonical_name(name);
     be_global->impl_ <<
       "    if (CORBA::ULong(enumval) >= " << vals.size() << ") {\n"
       "      if (OpenDDS::DCPS::log_level >= OpenDDS::DCPS::LogLevel::Warning) {\n"
       "        ACE_ERROR((LM_WARNING, \"(%P|%t) WARNING: "
         "%u is an invalid enumerated value for " << idl_name << "\\n\", enumval));\n"
       "      }\n"
       "      return false;\n"
       "    }\n";
     be_global->impl_ <<
       "  return strm << static_cast<CORBA::ULong>(enumval);\n";
   }
   {
     Function extraction("operator>>", "bool");
     extraction.addArg("strm", "Serializer&");
     extraction.addArg("enumval", cxx + "&");
     extraction.endArgs();
     be_global->impl_ <<
       "  CORBA::ULong temp = 0;\n"
       "  if (strm >> temp) {\n";
     be_global->impl_ <<
       "    if (temp >= " << vals.size() << ") {\n"
       "      strm.set_construction_status(Serializer::ElementConstructionFailure);\n"
       "      return false;\n"
       "    }\n";
     be_global->impl_ <<
       "    enumval = static_cast<" << cxx << ">(temp);\n"
       "    return true;\n"
       "  }\n"
       "  return false;\n";
   }
   return true;
 }

◆ gen_field_getValueFromSerialized()

void marshal_generator::gen_field_getValueFromSerialized	(	AST_Structure *	node,
		const std::string &	clazz
	)

static

Definition at line 3328 of file marshal_generator.cpp.

Referenced by metaclass_generator::gen_enum().

 {
   //loop through meta struct
   //check the id for a match to our id
   //if we are not a match, skip to the next field
   //if we are a match, deserialize the field
   const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
   std::string expr;
   const ExtensibilityKind exten = be_global->extensibility(node);
   const bool not_final = exten != extensibilitykind_final;
   const bool is_mutable = exten == extensibilitykind_mutable;
   const std::string actual_cpp_name = scoped(node->name());
   std::string cpp_name = actual_cpp_name;
   const Fields fields(node);
   const Fields::Iterator fields_end = fields.end();
   RtpsFieldCustomizer rtpsCustom(cpp_name);
 
   be_global->impl_ <<
     "  Value getValue(Serializer& strm, const char* field, const TypeSupportImpl* = 0) const\n"
     "  {\n"
     "    const Encoding& encoding = strm.encoding();\n"
     "    ACE_UNUSED_ARG(encoding);\n";
   marshal_generator::generate_dheader_code(
     "    if (!strm.read_delimiter(total_size)) {\n"
     "      throw std::runtime_error(\"Unable to reader delimiter in getValue\");\n"
     "    }\n", not_final);
   be_global->impl_ <<
     "    std::string base_field = field;\n"
     "    const size_t index = base_field.find('.');\n"
     "    std::string subfield;\n"
     "    if (index != std::string::npos) {\n"
     "      subfield = base_field.substr(index + 1);\n"
     "      base_field = base_field.substr(0, index);\n"
     "    }\n";
 
   if (is_mutable) {
     be_global->impl_ <<
       "    if (encoding.xcdr_version() != Encoding::XCDR_VERSION_NONE) {\n"
       "      unsigned field_id = map_name_to_id(base_field.c_str());\n"
       "      ACE_UNUSED_ARG(field_id);\n"
       "      unsigned member_id;\n"
       "      size_t field_size;\n"
       "      const size_t end_of_struct = strm.rpos() + total_size;\n"
       "      while (true) {\n"
       "        if (encoding.xcdr_version() == Encoding::XCDR_VERSION_2 &&\n"
       "            strm.rpos() >= end_of_struct) {\n"
       "          break;\n"
       "        }\n"
       "        bool must_understand = false;\n"
       "        if (!strm.read_parameter_id(member_id, field_size, must_understand)) {\n"
       "          throw std::runtime_error(\"Field \" + OPENDDS_STRING(field) + \" Deserialization "
       "Error for struct " << clazz << "\");\n"
       "        }\n"
       "        if (encoding.xcdr_version() == Encoding::XCDR_VERSION_1 &&\n"
       "            member_id == Serializer::pid_list_end) {\n"
       "          throw std::runtime_error(\"Field \" + OPENDDS_STRING(field) + \" not "
       "valid for struct " << clazz << "\");\n"
       "        }\n"
       "        const size_t end_of_field = strm.rpos() + field_size;\n"
       "        ACE_UNUSED_ARG(end_of_field);\n"
       "\n";
 
     std::ostringstream cases;
     for (Fields::Iterator i = fields.begin(); i != fields_end; ++i) {
       AST_Field* const field = *i;
       size_t size = 0;
       const OpenDDS::XTypes::MemberId id = be_global->get_id(field);
       std::string field_name = field->local_name()->get_string();
       AST_Type* const field_type = resolveActualType(field->field_type());
       Classification fld_cls = classify(field_type);
 
       cases << "        case " << id << ": {\n";
       if (fld_cls & CL_SCALAR) {
         const std::string cxx_type = to_cxx_type(field_type, size);
         const std::string val = (fld_cls & CL_STRING) ? (use_cxx11 ? "val" : "val.out()")
           : getWrapper("val", field_type, WD_INPUT);
         std::string boundsCheck, transformPrefix, transformSuffix;
         if (fld_cls & CL_ENUM) {
           const std::string enumName = dds_generator::scoped_helper(field_type->name(), "_");
           boundsCheck = "            if (val >= gen_" + enumName + "_names_size) {\n"
                         "              throw std::runtime_error(\"Enum value out of bounds\");\n"
                         "            }\n";
           transformPrefix = "gen_" + enumName + "_names[";
           transformSuffix = "]";
         }
         cases <<
           "          if (field_id == member_id) {\n"
           "            " << cxx_type << " val;\n" <<
           "            if (!(strm >> " << val << ")) {\n"
           "              throw std::runtime_error(\"Field '" << field_name << "' could not be deserialized\");\n" <<
           "            }\n" <<
           boundsCheck <<
           "            return " << transformPrefix << "val" << transformSuffix << ";\n"
           "          } else {\n"
           "            strm.skip(field_size);\n"
           "          }\n"
           "          break;\n"
           "        }\n";
       } else if (fld_cls & CL_STRUCTURE) {
         cases <<
           "          if (field_id == member_id) {\n"
           "            return getMetaStruct<" << scoped(field_type->name()) << ">().getValue(strm, subfield.c_str());\n"
           "          } else {\n"
           "            strm.skip(field_size);\n"
           "          }\n"
           "          break;\n"
           "        }\n";
       } else { // array, sequence, union:
         cases <<
           "          strm.skip(field_size);\n"
           "          break;\n"
           "        }\n";
       }
     }
     const std::string switch_cases = cases.str();
     std::string sw_indent = "          ";
     if (switch_cases.empty()) {
       sw_indent = "        ";
     } else {
       be_global->impl_ <<
         "        switch (member_id) {\n"
         << switch_cases <<
         "        default:\n";
     }
     be_global->impl_ <<
       sw_indent << "if (must_understand) {\n" <<
       sw_indent << "  if (DCPS_debug_level >= 8) {\n" <<
       sw_indent << "    ACE_DEBUG((LM_DEBUG, ACE_TEXT(\"(%P|%t) unknown must_understand field(%u) in "
       << cpp_name << "\\n\"), member_id));\n" <<
       sw_indent << "  }\n" <<
       sw_indent << "  throw std::runtime_error(\"member id did not exist in getValue\");\n" <<
       sw_indent << "}\n" <<
       sw_indent << "strm.skip(field_size);\n";
     if (!switch_cases.empty()) {
       be_global->impl_ <<
         "          break;\n"
         "        }\n";
     }
     be_global->impl_ <<
       "      }\n"
       "      if (!field[0]) {\n"   // if 'field' is the empty string...
       "        return 0;\n"        //    the return value is ignored
       "      }\n"
       "      throw std::runtime_error(\"Did not find field in getValue\");\n"
       "    }\n";
   }
   //The following is Appendable/Final
   //It is also used when Mutable but not in XCDR1 or XCDR2
   expr = "";
   for (Fields::Iterator i = fields.begin(); i != fields_end; ++i) {
     AST_Field* const field = *i;
     size_t size = 0;
     const std::string field_name = field->local_name()->get_string();
     const std::string idl_name = canonical_name(field);
     AST_Type* const field_type = resolveActualType(field->field_type());
     Classification fld_cls = classify(field_type);
     if (fld_cls & CL_SCALAR) {
       const std::string cxx_type = to_cxx_type(field_type, size);
       const std::string val = (fld_cls & CL_STRING) ? (use_cxx11 ? "val" : "val.out()")
           : getWrapper("val", field_type, WD_INPUT);
       std::string boundsCheck, transformPrefix, transformSuffix;
       if (fld_cls & CL_ENUM) {
         const std::string enumName = dds_generator::scoped_helper(field_type->name(), "_");
         boundsCheck = "      if (val >= gen_" + enumName + "_names_size) {\n"
                       "        throw std::runtime_error(\"Enum value out of bounds\");\n"
                       "      }\n";
         transformPrefix = "gen_" + enumName + "_names[";
         transformSuffix = "]";
       }
       expr +=
         "    if (base_field == \"" + idl_name + "\") {\n"
         "      " + cxx_type + " val;\n"
         "      if (!(strm >> " + val + ")) {\n"
         "        throw std::runtime_error(\"Field '" + idl_name + "' could "
         "not be deserialized\");\n"
         "      }\n"
         + boundsCheck +
         "      return " + transformPrefix + "val" + transformSuffix + ";\n"
         "    } else {\n";
       if (fld_cls & CL_STRING) {
         expr +=
           "      ACE_CDR::ULong len;\n"
           "      if (!(strm >> len)) {\n"
           "        throw std::runtime_error(\"String '" + idl_name +
           "' length could not be deserialized\");\n"
           "      }\n"
           "      if (!strm.skip(len)) {\n"
           "        throw std::runtime_error(\"String '" + idl_name +
           "' contents could not be skipped\");\n"
           "      }\n"
           "    }\n";
       } else {
         expr +=
           "      if (!strm.skip(1,  " + OpenDDS::DCPS::to_dds_string(size) + " )) {\n"
           "        throw std::runtime_error(\"Field '" + idl_name +
           "' could not be skipped\");\n"
           "      }\n"
           "    }\n";
       }
     } else if (fld_cls & CL_STRUCTURE) {
         expr +=
           "    if (base_field == \"" + idl_name + "\") {\n"
           "      return getMetaStruct<" + scoped(field_type->name()) + ">().getValue(strm, subfield.c_str());\n"
           "    } else {\n"
           "      if (!gen_skip_over(strm, static_cast<" + scoped(field_type->name()) + "*>(0))) {\n"
           "        throw std::runtime_error(\"Field '" + field_name + "' could not be skipped\");\n"
           "      }\n"
           "    }\n";
     } else { // array, sequence, union:
       std::string pre, post;
       if (!use_cxx11 && (fld_cls & CL_ARRAY)) {
         post = "_forany";
       } else if (use_cxx11 && (fld_cls & (CL_ARRAY | CL_SEQUENCE))) {
         pre = "IDL::DistinctType<";
         post = ", " + dds_generator::get_tag_name(scoped(field->field_type()->name())) + ">";
       }
       const std::string ptr = field->field_type()->anonymous() ?
         FieldInfo(*field).ptr_ : (pre + scoped(field->field_type()->name()) + post + '*');
       expr +=
         "    if (!gen_skip_over(strm, static_cast<" + ptr + ">(0))) {\n"
         "      throw std::runtime_error(\"Field \" + OPENDDS_STRING(field) + \" could not be skipped\");\n"
         "    }\n";
     }
   }
   be_global->impl_ <<
     expr <<
     "    if (!field[0]) {\n"   // if 'field' is the empty string...
     "      return 0;\n"        //    the return value is ignored
     "    }\n"
     "    throw std::runtime_error(\"Did not find field in getValue\");\n"
     "  }\n\n";
 }

◆ gen_struct()

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

virtual

Implements dds_generator.

Definition at line 3168 of file marshal_generator.cpp.

References ACE_TEXT_ALWAYS_CHAR, Function::addArg(), FieldInfo::arr_, be_global, OpenDDS::STUN::encoding(), Function::endArgs(), FieldFilter_All, FieldFilter_KeyOnly, FieldFilter_NestedKeyOnly, FieldInfo::is_new(), Intro::join(), scoped(), FieldInfo::seq_, OpenDDS::DCPS::serialized_size(), OpenDDS::DCPS::set_default(), and type_to_default().

 {
   NamespaceGuard ng;
   be_global->add_include("dds/DCPS/Serializer.h");
   const string cxx = scoped(name); // name as a C++ class
   const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
 
   {
     Function set_default("set_default", "void", "");
     set_default.addArg("stru", cxx + "&");
     set_default.endArgs();
     std::ostringstream contents;
     Intro intro;
     for (size_t i = 0; i < fields.size(); ++i) {
       AST_Field* const field = fields[i];
       AST_Type* const type = field->field_type();
       string field_name = string("stru.") + field->local_name()->get_string();
       if (use_cxx11) {
         field_name += "()";
       }
       contents << type_to_default("  ", type, field_name, type->anonymous());
     }
     intro.join(be_global->impl_, "  ");
     be_global->impl_ << contents.str();
   }
 
   const special_struct* special_struct_ptr = get_special_struct(cxx);
   if (special_struct_ptr) {
     return special_struct_ptr->gen(cxx);
   }
 
   FieldInfo::EleLenSet anonymous_seq_generated;
   for (size_t i = 0; i < fields.size(); ++i) {
     if (fields[i]->field_type()->anonymous()) {
       FieldInfo af(*fields[i]);
       if (af.arr_) {
         gen_anonymous_array(af);
       } else if (af.seq_ && af.is_new(anonymous_seq_generated)) {
         gen_anonymous_sequence(af);
       }
     }
   }
 
   if (!generate_struct_serialization_functions(node, FieldFilter_All) ||
       !generate_struct_serialization_functions(node, FieldFilter_NestedKeyOnly)) {
     return false;
   }
 
   IDL_GlobalData::DCPS_Data_Type_Info* info = idl_global->is_dcps_type(name);
   const bool is_topic_type = be_global->is_topic_type(node);
   TopicKeys keys;
   if (is_topic_type) {
     keys = TopicKeys(node);
     info = 0; // Annotations Override DCPS_DATA_TYPE
 
     if (!generate_struct_serialization_functions(node, FieldFilter_KeyOnly)) {
       return false;
     }
   }
 
   if ((info || is_topic_type) &&
       !generate_marshal_traits(node, cxx, be_global->extensibility(node), keys, info)) {
     return false;
   }
 
   if (info && !is_topic_type) {
     {
       Function serialized_size("serialized_size", "void");
       serialized_size.addArg("encoding", "const Encoding&");
       serialized_size.addArg("size", "size_t&");
       serialized_size.addArg("stru", "const KeyOnly<const " + cxx + ">");
       serialized_size.endArgs();
 
       be_global->impl_ <<
         "  switch (encoding.xcdr_version()) {\n";
       const char* indent = "    ";
       for (unsigned e = 0; e <= Encoding::KIND_UNALIGNED_CDR; ++e) {
         string expr;
         Intro intro;
         const Encoding::Kind encoding = static_cast<Encoding::Kind>(e);
         if (!iterate_over_keys(indent, encoding, node, cxx, info, 0,
               serialized_size_iteration, 0, &expr, &intro)) {
           return false;
         }
         be_global->impl_ <<
           "  case " << encoding_to_xcdr_version(encoding) << ":\n"
           "    {\n";
         intro.join(be_global->impl_, indent);
         be_global->impl_
           << expr <<
           "    break;\n"
           "    }\n";
       }
       be_global->impl_ <<
         "  }\n";
     }
 
     {
       Function insertion("operator<<", "bool");
       insertion.addArg("strm", "Serializer&");
       insertion.addArg("stru", "KeyOnly<const " + cxx + ">");
       insertion.endArgs();
 
       bool first = true;
       std::string expr;
       Intro intro;
       const char* indent = "  ";
 
       IDL_GlobalData::DCPS_Data_Type_Info_Iter iter(info->key_list_);
       for (ACE_TString* kp = 0; iter.next(kp) != 0; iter.advance()) {
         const string key_name = ACE_TEXT_ALWAYS_CHAR(kp->c_str());
         AST_Type* const field_type = find_type(node, key_name);
         if (first) {
           first = false;
         } else {
           expr += "\n    && ";
         }
         expr += streamCommon(indent, 0, key_name, field_type, "<< stru.value", false, intro);
       }
 
       intro.join(be_global->impl_, indent);
       be_global->impl_ << "  return " << (first ? "true" : expr) << ";\n";
     }
 
     {
       Function extraction("operator>>", "bool");
       extraction.addArg("strm", "Serializer&");
       extraction.addArg("stru", "KeyOnly<" + cxx + ">");
       extraction.endArgs();
 
       bool first = true;
       Intro intro;
       std::string expr;
       const std::string indent = "  ";
 
       IDL_GlobalData::DCPS_Data_Type_Info_Iter iter(info->key_list_);
       for (ACE_TString* kp = 0; iter.next(kp) != 0; iter.advance()) {
         const string key_name = ACE_TEXT_ALWAYS_CHAR(kp->c_str());
         AST_Type* const field_type = find_type(node, key_name);
         if (first) {
           first = false;
         } else {
           expr += "\n    && ";
         }
         expr += streamCommon(indent, 0, key_name, field_type, ">> stru.value", false, intro);
       }
 
       intro.join(be_global->impl_, indent);
       be_global->impl_ << "  return " << (first ? "true" : expr) << ";\n";
     }
   }
 
   return true;
 }

◆ gen_typedef()

bool marshal_generator::gen_typedef	(	AST_Typedef *	node,
		UTL_ScopedName *	name,
		AST_Type *	base,
		const char *	repoid
	)

virtual

Implements dds_generator.

Definition at line 1876 of file marshal_generator.cpp.

 {
   switch (base->node_type()) {
   case AST_Decl::NT_sequence:
     gen_sequence(name, dynamic_cast<AST_Sequence*>(base));
     break;
   case AST_Decl::NT_array:
     gen_array(name, dynamic_cast<AST_Array*>(base));
     break;
   default:
     return true;
   }
   return true;
 }

◆ gen_union()

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

virtual

Implements dds_generator.

Definition at line 3859 of file marshal_generator.cpp.

References Function::addArg(), OpenDDS::DCPS::array_count(), be_global, AstTypeClassification::CL_ENUM, AstTypeClassification::classify(), Function::endArgs(), extensibilitykind_final, extensibilitykind_mutable, FieldFilter_KeyOnly, FieldFilter_NestedKeyOnly, generate_dheader_code(), generateSwitchForUnion(), getWrapper(), OPENDDS_HAS_EXPLICIT_INTS, AstTypeClassification::resolveActualType(), scoped(), OpenDDS::DCPS::serialized_size(), OpenDDS::DCPS::set_default(), tryconstructfailaction_use_default, type_to_default(), WD_INPUT, and WD_OUTPUT.

 {
   NamespaceGuard ng;
   be_global->add_include("dds/DCPS/Serializer.h");
   string cxx = scoped(name); // name as a C++ class
   Classification disc_cls = classify(discriminator);
 
   const ExtensibilityKind exten = be_global->extensibility(node);
   const bool not_final = exten != extensibilitykind_final;
 
   {
     // Define the set_default function in the header and implementation file.
     const std::string varname("uni");
     Function set_default("set_default", "void", "");
     set_default.addArg(varname.c_str(), cxx + "&");
     set_default.endArgs();
 
     // Add a reference to the idl file, if the descriminator is user defined.
     AST_Type* disc_type = resolveActualType(discriminator);
     const Classification disc_cls = classify(disc_type);
     if (!disc_type->in_main_file() && disc_type->node_type() != AST_Decl::NT_pre_defined) {
       be_global->add_referenced(disc_type->file_name().c_str());
     }
 
     // Determine the default enum value
     ACE_CDR::ULong default_enum_val = 0;
     if (disc_cls & CL_ENUM) {
       AST_Enum* enu = dynamic_cast<AST_Enum*>(disc_type);
       UTL_ScopeActiveIterator i(enu, UTL_Scope::IK_decls);
       AST_EnumVal *item = dynamic_cast<AST_EnumVal*>(i.item());
       default_enum_val = item->constant_value()->ev()->u.eval;
     }
 
     // Search the union branches to find the default value according to
     // Table 9 of the XTypes spec v1.3
     bool found = false;
     for (std::vector<AST_UnionBranch*>::const_iterator itr = branches.begin(); itr < branches.end() && !found; ++itr) {
       AST_UnionBranch* branch = *itr;
       for (unsigned i = 0; i < branch->label_list_length(); ++i) {
         AST_UnionLabel* ul = branch->label(i);
         if (ul->label_kind() != AST_UnionLabel::UL_default) {
           AST_Expression::AST_ExprValue* ev = branch->label(i)->label_val()->ev();
           if ((ev->et == AST_Expression::EV_enum && ev->u.eval == default_enum_val) ||
 #if OPENDDS_HAS_EXPLICIT_INTS
               (ev->et == AST_Expression::EV_uint8 && ev->u.uint8val == 0) ||
               (ev->et == AST_Expression::EV_int8 && ev->u.int8val == 0) ||
 #endif
               (ev->et == AST_Expression::EV_short && ev->u.sval == 0) ||
               (ev->et == AST_Expression::EV_ushort && ev->u.usval == 0) ||
               (ev->et == AST_Expression::EV_long && ev->u.lval == 0) ||
               (ev->et == AST_Expression::EV_ulong && ev->u.ulval == 0) ||
               (ev->et == AST_Expression::EV_longlong && ev->u.llval == 0) ||
               (ev->et == AST_Expression::EV_ulonglong && ev->u.ullval == 0) ||
               (ev->et == AST_Expression::EV_float && ev->u.fval == 0) ||
               (ev->et == AST_Expression::EV_double && ev->u.dval == 0) ||
               (ev->et == AST_Expression::EV_longdouble && ev->u.sval == 0) ||
               (ev->et == AST_Expression::EV_char && ev->u.cval == 0) ||
               (ev->et == AST_Expression::EV_wchar && ev->u.wcval == 0) ||
               (ev->et == AST_Expression::EV_octet && ev->u.oval == 0) ||
               (ev->et == AST_Expression::EV_bool && ev->u.bval == 0))
           {
             gen_union_default(branch, varname);
             found = true;
             break;
           }
         }
       }
     }
 
     // If a default value was not found, just set the discriminator to the
     // default value.
     if (!found) {
       be_global->impl_ << " " << scoped(discriminator->name()) << " temp;\n";
       be_global->impl_ << type_to_default("", discriminator, "  temp");
       be_global->impl_ << "  " << varname << "._d(temp);\n";
     }
   }
 
   for (size_t i = 0; i < array_count(special_unions); ++i) {
     if (special_unions[i].check(cxx)) {
       return special_unions[i].gen(cxx, node, discriminator, branches);
     }
   }
 
   const string wrap_out = getWrapper("uni._d()", discriminator, WD_OUTPUT);
   {
     Function serialized_size("serialized_size", "void");
     serialized_size.addArg("encoding", "const Encoding&");
     serialized_size.addArg("size", "size_t&");
     serialized_size.addArg("uni", "const " + cxx + "&");
     serialized_size.endArgs();
 
     marshal_generator::generate_dheader_code("    serialized_size_delimiter(encoding, size);\n", not_final, false);
 
     if (exten == extensibilitykind_mutable) {
       be_global->impl_ <<
         "  size_t mutable_running_total = 0;\n"
         "  serialized_size_parameter_id(encoding, size, mutable_running_total);\n";
     }
 
     if (disc_cls & CL_ENUM) {
       be_global->impl_ <<
         "  primitive_serialized_size_ulong(encoding, size);\n";
     } else {
       be_global->impl_ <<
         "  primitive_serialized_size(encoding, size, " << wrap_out << ");\n";
     }
 
     generateSwitchForUnion(node, "uni._d()",
                            exten == extensibilitykind_mutable ? findSizeMutableUnion : findSizeCommon,
                            branches, discriminator, "", "", cxx.c_str());
 
     if (exten == extensibilitykind_mutable) {
       // TODO: XTypes B will need to edit this code to add the pid for the end of mutable unions.
       // Until this change is made, XCDR1 will NOT be functional
       be_global->impl_ <<
         "  serialized_size_list_end_parameter_id(encoding, size, mutable_running_total);\n";
     }
   }
   {
     Function insertion("operator<<", "bool");
     insertion.addArg("strm", "Serializer&");
     insertion.addArg("uni", "const " + cxx + "&");
     insertion.endArgs();
 
     be_global->impl_ <<
       "  const Encoding& encoding = strm.encoding();\n"
       "  ACE_UNUSED_ARG(encoding);\n";
     marshal_generator::generate_dheader_code(
       "    serialized_size(encoding, total_size, uni);\n"
       "    if (!strm.write_delimiter(total_size)) {\n"
       "      return false;\n"
       "    }\n", not_final);
 
     // EMHEADER for discriminator
     if (exten == extensibilitykind_mutable) {
       be_global->impl_ <<
         "  size_t size = 0;\n";
 
       if (disc_cls & CL_ENUM) {
         be_global->impl_ <<
           "  primitive_serialized_size_ulong(encoding, size);\n";
       } else {
         be_global->impl_ <<
           "  primitive_serialized_size(encoding, size, " << wrap_out << ");\n";
       }
 
       be_global->impl_ <<
         "  if (!strm.write_parameter_id(0, size)) {\n"
         "    return false;\n"
         "  }\n"
         "  size = 0;\n";
     }
 
     be_global->impl_ <<
       streamAndCheck("<< " + wrap_out);
     if (generateSwitchForUnion(node, "uni._d()", streamCommon, branches,
                                discriminator, "return", "<< ", cxx.c_str(),
                                false, true, true,
                                exten == extensibilitykind_mutable ? findSizeCommon : 0)) {
       be_global->impl_ <<
         "  return true;\n";
     }
   }
   {
     Function extraction("operator>>", "bool");
     extraction.addArg("strm", "Serializer&");
     extraction.addArg("uni", cxx + "&");
     extraction.endArgs();
 
     be_global->impl_ <<
       "  const Encoding& encoding = strm.encoding();\n"
       "  ACE_UNUSED_ARG(encoding);\n";
     marshal_generator::generate_dheader_code(
       "    if (!strm.read_delimiter(total_size)) {\n"
       "      return false;\n"
       "    }\n", not_final);
 
     if (exten == extensibilitykind_mutable) {
       // EMHEADER for discriminator
       be_global->impl_ <<
         "  unsigned member_id;\n"
         "  size_t field_size;\n"
         "  bool must_understand = false;\n"
         "  if (!strm.read_parameter_id(member_id, field_size, must_understand)) {\n"
         "    return false;\n"
         "  }\n";
       TryConstructFailAction try_construct = be_global->union_discriminator_try_construct(node);
       be_global->impl_ <<
         "  " << scoped(discriminator->name()) << " disc;\n"
         "  if (!(strm >> disc)) {\n";
       if (try_construct == tryconstructfailaction_use_default) {
         be_global->impl_ <<
           "    set_default(uni);\n"
           "    if (!strm.read_parameter_id(member_id, field_size, must_understand)) {\n"
           "      return false;\n"
           "    }\n"
           "    strm.skip(field_size);\n"
           "    strm.set_construction_status(Serializer::ConstructionSuccessful);\n"
           "    return true;\n";
       } else {
         be_global->impl_ <<
           "    if (!strm.read_parameter_id(member_id, field_size, must_understand)) {\n"
           "      return false;\n"
           "    }\n"
           "    strm.skip(field_size);\n"
           "    strm.set_construction_status(Serializer::ElementConstructionFailure);\n"
           "    return false;\n";
       }
       be_global->impl_ << "  }\n";
 
       be_global->impl_ <<
         "  member_id = 0;\n"
         "  field_size = 0;\n"
         "  must_understand = false;\n";
 
       const char prefix[] =
         "    if (!strm.read_parameter_id(member_id, field_size, must_understand)) {\n"
         "      return false;\n"
         "    }\n";
       if (generateSwitchForUnion(node, "disc", streamCommon, branches,
                                  discriminator, prefix, ">> ", cxx.c_str())) {
         be_global->impl_ <<
           "  return true;\n";
       }
     } else {
       be_global->impl_ <<
         "  " << scoped(discriminator->name()) << " disc;\n" <<
         streamAndCheck(">> " + getWrapper("disc", discriminator, WD_INPUT));
       if (generateSwitchForUnion(node, "disc", streamCommon, branches,
           discriminator, "", ">> ", cxx.c_str())) {
         be_global->impl_ <<
           "  return true;\n";
       }
     }
   }
 
   gen_union_key_serializers(node, FieldFilter_NestedKeyOnly);
   gen_union_key_serializers(node, FieldFilter_KeyOnly);
 
   TopicKeys keys(node);
   return generate_marshal_traits(node, cxx, exten, keys);
 }

◆ gen_union_default()

void marshal_generator::gen_union_default	(	AST_UnionBranch *	branch,
		const std::string &	varname
	)

private

Definition at line 4105 of file marshal_generator.cpp.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), getWrapper(), AstTypeClassification::resolveActualType(), scoped(), type_to_default(), and WD_INPUT.

 {
   AST_Type* br = resolveActualType(branch->field_type());
   const Classification br_cls = classify(br);
   const std::string tmpname = "tmp";
 
   if (br_cls & (CL_SEQUENCE | CL_ARRAY | CL_STRUCTURE | CL_UNION)) {
     be_global->impl_ << " " << scoped(branch->field_type()->name()) << " "
                      << getWrapper(tmpname, branch->field_type(), WD_INPUT) << ";\n";
   }
 
   if (br_cls & (CL_STRUCTURE | CL_UNION)) {
     be_global->impl_ << type_to_default("  ", branch->field_type(), tmpname);
     be_global->impl_ << "  " << varname << "." << branch->local_name()->get_string() << "(tmp);\n";
   } else {
     be_global->impl_ << type_to_default("  ", branch->field_type(),
                                         varname + "." + branch->local_name()->get_string(),
                                         false, true);
   }
 }

◆ generate_dheader_code()

void marshal_generator::generate_dheader_code	(	const std::string &	code,
		bool	dheader_required,
		bool	is_ser_func = `true`
	)

static

Definition at line 3154 of file marshal_generator.cpp.

References be_global.

Referenced by gen_enum(), gen_field_getValueFromSerialized(), metaclass_generator::gen_struct(), gen_typedef(), metaclass_generator::gen_typedef(), gen_union(), and metaclass_generator::gen_union().

 {
   //DHeader appears on aggregated types that are mutable or appendable in XCDR2
   //DHeader also appears on ALL sequences and arrays of non-primitives
   if (dheader_required) {
     if (is_ser_func) {
       be_global->impl_ << "  size_t total_size = 0;\n";
     }
     be_global->impl_ << "  if (encoding.xcdr_version() == Encoding::XCDR_VERSION_2) {\n"
       << code <<
       "  }\n";
   }
 }

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Detailed Description

Member Function Documentation

◆ gen_enum()

◆ gen_field_getValueFromSerialized()

◆ gen_struct()

◆ gen_typedef()

◆ gen_union()

◆ gen_union_default()

◆ generate_dheader_code()