Implement @optional annotation

MPC/config/opendds_uses_cxx17.mpb

@@ -0,0 +1,5 @@
+project: dcpslib {
+  avoids += no_cxx17
+  requires += no_opendds_safety_profile
+  macros += OPENDDS_HAS_CXX17
+}

configure

@@ -622,7 +622,6 @@ if (!exists $platforminfo{$opts{'host'}} ||
 }
 print "host system is: $opts{'host'}\n" if $opts{'verbose'};
 
-
 $opts{'target'} = $opts{'host'} unless $opts{'target'};
 
 if (!exists $platforminfo{$opts{'target'}}) {
@@ -822,9 +821,17 @@ EOF
       }
     }
 
-    if ($opts{'std'} && $opts{'std'} =~ /(0x|11|1y|14|1z|17|2a|20|2b|23)$/) {
-      push(@{$opts{'features'}}, 'no_cxx11=0');
-      print "Compiler has >= C++11 support\n" if $opts{'verbose'};
+    if ($opts{'std'}) {
+      my $cpp17 = qr/(17|2a|20|2b|23)/;
+      if ($opts{'std'} =~ /(0x|11|1y|14|1z|$cpp17)$/) {
+        push(@{$opts{'features'}}, 'no_cxx11=0');
+        print "Compiler has >= C++11 support\n" if $opts{'verbose'};
+      }
+
+      if ($opts{'std'} =~ /$cpp17$/) {
+        push(@{$opts{'features'}}, 'no_cxx17=0');
+        print "Compiler has >= C++17 support\n" if $opts{'verbose'};
+      }
     }
   }
 }

dds/idl/dds_generator.cpp

@@ -397,7 +397,7 @@ string type_to_default_array(const std::string& indent, AST_Type* type, const st
 }
 
 string type_to_default(const std::string& indent, AST_Type* type, const string& name,
-  bool is_anonymous, bool is_union)
+  bool is_anonymous, bool is_union, bool is_optional)
 {
   AST_Type* actual_type = resolveActualType(type);
   Classification fld_cls = classify(actual_type);
@@ -409,7 +409,10 @@ string type_to_default(const std::string& indent, AST_Type* type, const string&
     pre = "(";
     post = ")";
   }
-  if (fld_cls & (CL_STRUCTURE | CL_UNION)) {
+
+  if (is_optional) {
+    return indent + name + " = std::nullopt;\n";
+  } else 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(

dds/idl/dds_generator.h

@@ -715,7 +715,7 @@ inline 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);
+  const std::string& name, bool is_anonymous = false, bool is_union = false, bool is_optional = false);
 
 inline
 void generateBranchLabels(AST_UnionBranch* branch, AST_Type* discriminator,

dds/idl/dynamic_data_adapter_generator.cpp

@@ -169,6 +169,12 @@ namespace {
       } else {
         value += (use_cxx11 ? "_" : "") + cpp_field_name;
       }
+
+      if (field != 0) {
+        const bool is_optional = be_global->is_optional(field);
+        if (is_optional) value += ".value()";
+      }
+
       generate_op(4, set, field_type, type_name, op_type, is_complex,
         value + extra_access, rc_dest);
       if (union_node && set) {

dds/idl/langmap_generator.cpp

@@ -1476,7 +1476,12 @@ struct Cxx11Generator : GeneratorBase {
       }
     }
 
-    const std::string lang_field_type = generator_->map_type(field);
+    const bool is_optional = be_global->is_optional(field);
+    const std::string lang_field_type = is_optional ? "std::optional<" + generator_->map_type(field) + ">" : generator_->map_type(field);
+    if (is_optional) {
+      be_global->add_include("<optional>", BE_GlobalData::STREAM_LANG_H);
+    }
+
     const std::string assign_pre = "{ _" + af.name_ + " = ",
       assign = assign_pre + "val; }\n",
       move = assign_pre + "std::move(val); }\n",

dds/idl/marshal_generator.cpp

@@ -1571,40 +1571,57 @@ namespace {
   {
     const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
     const bool is_union_member = prefix == "uni";
+    const bool is_optional = field != 0 ? be_global->is_optional(field) : false;
 
     AST_Type* const actual_type = resolveActualType(type);
     const Classification fld_cls = classify(actual_type);
 
-    const string qual = prefix + '.' + insert_cxx11_accessor_parens(name, is_union_member);
+    const std::string field_name = prefix + '.' + insert_cxx11_accessor_parens(name, is_union_member);
+    const string qual = prefix + '.' + insert_cxx11_accessor_parens(name, is_union_member)
+                        + (is_optional ? ".value()" : "");
+
+    std::string line = "";
+    if (is_optional) {
+      line += indent + "primitive_serialized_size_boolean(encoding, size);\n"
+            + indent + "if (" + field_name + ") {\n";
+    }
 
     if (fld_cls & CL_ENUM) {
-      return indent + "primitive_serialized_size_ulong(encoding, size);\n";
+      line += indent + "primitive_serialized_size_ulong(encoding, size);\n";
     } else if (fld_cls & CL_STRING) {
       const string suffix = is_union_member ? "" : ".in()";
       const string get_size = use_cxx11 ? (qual + ".size()")
         : ("ACE_OS::strlen(" + qual + suffix + ")");
-      return indent + "primitive_serialized_size_ulong(encoding, size);\n" +
+
+      line += indent + "primitive_serialized_size_ulong(encoding, size);\n" +
         indent + "size += " + get_size
         + ((fld_cls & CL_WIDE) ? " * char16_cdr_size;\n"
                                : " + 1;\n");
     } else if (fld_cls & CL_PRIMITIVE) {
       AST_PredefinedType* const p = dynamic_cast<AST_PredefinedType*>(actual_type);
       if (p->pt() == AST_PredefinedType::PT_longdouble) {
         // special case use to ACE's NONNATIVE_LONGDOUBLE in CDR_Base.h
-        return indent +
+        line += indent +
           "primitive_serialized_size(encoding, size, ACE_CDR::LongDouble());\n";
+      } else {
+        line += indent + "primitive_serialized_size(encoding, size, " +
+          getWrapper(qual, actual_type, WD_OUTPUT) + ");\n";
       }
-      return indent + "primitive_serialized_size(encoding, size, " +
-        getWrapper(qual, actual_type, WD_OUTPUT) + ");\n";
     } else if (fld_cls == CL_UNKNOWN) {
       return ""; // warning will be issued for the serialize functions
     } else { // sequence, struct, union, array
       RefWrapper wrapper(type, field_type_name(dynamic_cast<AST_Field*>(field), type),
-        prefix + "." + insert_cxx11_accessor_parens(name, is_union_member));
+        prefix + "." + insert_cxx11_accessor_parens(name, is_union_member) + (is_optional ? ".value()" : ""));
       wrapper.nested_key_only_ = wrap_nested_key_only;
       wrapper.done(&intro);
-      return indent + "serialized_size(encoding, size, " + wrapper.ref() + ");\n";
+      line += indent + "serialized_size(encoding, size, " + wrapper.ref() + ");\n";
+    }
+
+    if (is_optional) {
+      line += indent + "}\n";
     }
+
+    return line;
   }
 
   string findSizeMutableUnion(const string& indent, AST_Decl* node, const string& name, AST_Type* type,
@@ -1639,6 +1656,7 @@ namespace {
   {
     const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
     const bool is_union_member = prefix.substr(3) == "uni";
+    const bool is_optional = field != 0 ? be_global->is_optional(field) : false;
 
     AST_Type* const actual_type = resolveActualType(type);
     const Classification fld_cls = classify(actual_type);
@@ -1672,6 +1690,10 @@ namespace {
       const bool accessor = local.size() > 2 && local.substr(local.size() - 2) == "()";
       if (fld_cls & CL_STRING) {
         if (!accessor && !use_cxx11) {
+          if (is_optional) {
+            local += ".value()";
+          }
+
           local += ".in()";
         }
         if ((fld_cls & CL_BOUNDED)) {
@@ -1688,10 +1710,11 @@ namespace {
   }
 
   std::string generate_field_stream(
-    const std::string& indent, AST_Field* field, const std::string& prefix,
+    const std::string& indent, AST_Field* field, const std::string& prefix, const std::string& field_name,
     bool wrap_nested_key_only, Intro& intro)
   {
     FieldInfo af(*field);
+
     if (af.anonymous()) {
       RefWrapper wrapper(af.type_, af.scoped_type_,
         prefix + "." + insert_cxx11_accessor_parens(af.name_));
@@ -1700,7 +1723,7 @@ namespace {
       return "(strm " + wrapper.stream() + ")";
     }
     return streamCommon(
-      indent, field, field->local_name()->get_string(), field->field_type(), prefix,
+      indent, field, field_name, field->field_type(), prefix,
       wrap_nested_key_only, intro);
   }
 
@@ -2475,7 +2498,7 @@ namespace {
           cases <<
             "      case " << id << ": {\n"
             "        if (!" << generate_field_stream(
-            indent, field, ">> stru" + value_access, wrap_nested_key_only, intro) << ") {\n";
+            indent, field, ">> stru" + value_access, field->local_name()->get_string(), wrap_nested_key_only, intro) << ") {\n";
           AST_Type* const field_type = resolveActualType(field->field_type());
           const Classification fld_cls = classify(field_type);
 
@@ -2572,6 +2595,8 @@ namespace {
       expr = "";
       for (Fields::Iterator i = fields.begin(); i != fields_end; ++i) {
         AST_Field* const field = *i;
+        const bool is_optional = be_global->is_optional(field);
+
         if (expr.size() && exten != extensibilitykind_appendable) {
           expr += "\n    && ";
         }
@@ -2603,16 +2628,44 @@ namespace {
           }
           expr +=
             "  if (reached_end_of_struct) {\n" +
-            type_to_default("    ", type, stru_field_name, type->anonymous()) +
-            "  } else {\n"
-            "    if (!";
+            type_to_default("    ", type, stru_field_name, type->anonymous(), false, is_optional) +
+            "  } else {\n";
+          if (!is_optional) {
+            expr += "    if (!";
+          }
+        }
+
+        // TODO(tyler) This feels kind of hacky
+        // Can the optional branch be isolated completely
+        // Assigns strm value to temporary values
+        if (is_optional) {
+            //TODO(tyler) Is there an easier way to deal with strings here
+            AST_Type* const field_type = resolveActualType(field->field_type());
+            Classification fld_cls = classify(field_type);
+            const std::string type_name = fld_cls & CL_STRING ? "String" : field->field_type()->full_name();
+            const std::string has_value_name = field_name + "_has_value";
+            expr += "    bool " + field_name + "_has_value = false;\n";
+            expr += "    strm >> ACE_InputCDR::to_boolean(" + has_value_name + ");\n";
+            expr += "    " + type_name + " " + field_name + "_tmp;\n";
+            expr += "    if (" + has_value_name + " && !";
+            expr += "(strm >> " + field_name + "_tmp)";
+        } else {
+          expr += generate_field_stream(
+            indent, field, ">> stru" + value_access, field->local_name()->get_string(), wrap_nested_key_only, intro);
         }
-        expr += generate_field_stream(
-          indent, field, ">> stru" + value_access, wrap_nested_key_only, intro);
         if (is_appendable) {
           expr += ") {\n"
             "      return false;\n"
             "    }\n";
+
+          // Copy temporaries to the struct
+          if (is_optional) {
+            string stru_field_name = "stru" + value_access + "." + field_name;
+            if (use_cxx11) {
+              stru_field_name += "()";
+            }
+            expr += "    if (" + field_name + "_has_value) " + stru_field_name + " = " + field_name + "_tmp;\n";
+          }
           if (cond.empty()) {
             expr +=
             "  }\n";
@@ -2756,7 +2809,7 @@ namespace {
             "    }\n"
             "    size = 0;\n"
             "    if (!" << generate_field_stream(
-              mutable_indent, field, "<< stru" + value_access, wrap_nested_key_only, intro)
+              mutable_indent, field, "<< stru" + value_access, field->local_name()->get_string(), wrap_nested_key_only, intro)
             << ") {\n"
             "      return false;\n"
             "    }\n";
@@ -2773,14 +2826,25 @@ namespace {
       string expr;
       for (Fields::Iterator i = fields.begin(); i != fields_end; ++i) {
         AST_Field* const field = *i;
+        const bool is_optional = be_global->is_optional(field);;
         if (expr.size()) expr += "\n    && ";
         const string field_name = field->local_name()->get_string(),
           cond = rtpsCustom.getConditional(field_name);
         if (!cond.empty()) {
           expr += "(!(" + cond + ") || ";
         }
-        expr += generate_field_stream(
-          indent, field, "<< stru" + value_access, wrap_nested_key_only, intro);
+
+        if (is_optional) {
+          expr += "(strm << ACE_OutputCDR::from_boolean(stru" + value_access + "." + field_name + "().has_value()) && ";
+          expr += "stru" + value_access + "." + field_name + "().has_value() ? ";
+          expr += generate_field_stream(
+            indent, field, "<< stru" + value_access, field_name + ".value", wrap_nested_key_only, intro);
+          expr += " : true)";
+        } else {
+          expr += generate_field_stream(
+            indent, field, "<< stru" + value_access, field_name, wrap_nested_key_only, intro);
+        }
+
         if (!cond.empty()) {
           expr += ")";
         }
@@ -2841,7 +2905,7 @@ bool marshal_generator::gen_struct(AST_Structure* node,
       if (use_cxx11) {
         field_name += "()";
       }
-      contents << type_to_default("  ", type, field_name, type->anonymous());
+      contents << type_to_default("  ", type, field_name, type->anonymous(), false, be_global->is_optional(field));
     }
     intro.join(be_global->impl_, "  ");
     be_global->impl_ << contents.str();

dds/idl/metaclass_generator.cpp

@@ -45,7 +45,8 @@ namespace {
   {
     const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
     const Classification cls = classify(field->field_type());
-    const std::string fieldName = field->local_name()->get_string();
+    std::string fieldName = field->local_name()->get_string();
+
     const std::string idl_name = canonical_name(field);
     if (cls & CL_SCALAR) {
       std::string prefix, suffix;
@@ -61,6 +62,11 @@ namespace {
       } else if (use_cxx11) {
         suffix += "()";
       }
+
+      if (be_global->is_optional(field)) {
+        fieldName += "().value";
+      }
+
       const std::string string_to_ptr = use_cxx11 ? "" : ".in()";
       be_global->impl_ <<
         "    if (std::strcmp(field, \"" << idl_name << "\") == 0) {\n"
@@ -69,8 +75,12 @@ namespace {
         "    }\n";
       be_global->add_include("<cstring>", BE_GlobalData::STREAM_CPP);
     } else if (cls & CL_STRUCTURE) {
-      delegateToNested(idl_name, field,
-                       "&typed." + std::string(use_cxx11 ? "_" : "") + fieldName);
+      std::string fieldAccessor = "&typed." + std::string(use_cxx11 ? "_" : "") + fieldName;
+      if (be_global->is_optional(field)) {
+        fieldAccessor += ".value()";
+      }
+
+      delegateToNested(idl_name, field, fieldAccessor);
       be_global->add_include("<cstring>", BE_GlobalData::STREAM_CPP);
     }
   }