eclipse-aascw / aas-core-codegen / 35778356506

90%

push

github

Compose the C++ XML serialization (#746)

Every class and every property wrote out its own framing. The start
element, the content and the stop element were spelled out in each of
the ``Serialize<Cls>AsElement``, once more in the ``switch`` of
``Serialize`` for the root, and each of the properties re-emitted
the guard for its optional, the dereference of its instance and, for
a list, a lambda naming the item type in full. This factors that framing
out, so that a class names only itself and what writes it.

**An element** is framed in one place. Everything which writes tags --
the element of a class, the ``<v>`` of a list item, the positional
``<v1>`` of a tuple item -- differs only in the name and in the content,
so all of them come through ``WriteElement``.

    // before, 35 lines in each of the ``Serialize<Cls>AsElement``
    common::optional<xml_common::SerializationError> error;

    writer.StartElement(
      "extension"
    );
    if (writer.error().has_value()) {
      return writer.move_error();
    }

    error = SerializeExtensionAsSequence(
      that,
      writer
    );
    ...23 more lines of stop element, flush and error checks...

    // after
    return WriteElement(
      "extension",
      that,
      writer,
      SerializeExtensionAsSequence
    );

**A property** hands its value over exactly as its getter returns it.
``WriteProperty`` has an overload per way the value arrives -- a value,
an instance, an optional -- so the framer dereferences and writes
nothing at all for a property which was not given, and the call site
says neither.

    // before
    if (that.semantic_id().has_value()) {
      error = SerializePropertyAsElement(
        "semanticId",
        *(*(that.semantic_id())),
        writer,
        iteration::Property::kSemanticId,
        SerializeReferenceAsSequence
      );
      if (error.has_value()) {
        return error;
      }
    }

    // after
    error = WriteProperty(
      "semanticId",
      that.sema... (continued)

92 of 97 new or added lines in 1 file covered. (94.85%)

36928 of 42357 relevant lines covered (87.18%)

2.62 hits per line