eclipse-aascw / aas-core-codegen / 35799683348

90%

push

github

Compose the C++ JSON serialization (#748)

Every property spelled out its own procedure, and the procedure said
nothing about the property it belonged to. We introduce the pieces it is
made of and let a property be one call.

**A serializer can fail only where a number can be reached from what it
serializes.** JSON holds neither an infinity nor a not-a-number, and an
integer only within [-2^53 + 1, 2^53 - 1]; everything else goes as it
comes. A serializer which can not fail now gives the JSON out plainly,
so neither it nor its caller carries an error which could never be set.

    // no number reachable
    nlohmann::json SerializeReference(
      const types::IReference& that
    );

    // a number is reachable
    std::pair<
      common::optional<nlohmann::json>,
      common::optional<SerializationError>
    > SerializeSomething(
      const types::ISomething& that
    );

This replaces a one-level walk which was wrong in both directions. A
bare ``float`` property routed to a fallible serializer while the walk
looked only for an ``int``, so the class never declared ``error`` and
the generated code did not compile; no fixture caught it,
``primitive_types`` carrying a ``some_int`` beside its ``some_float``.
In the other direction an enumeration, which can not fail, made its
class fallible. The answer is now a fixed point over the whole type
graph, and a JSON-able value counts as reaching a number, since its
shape is known only at run time.

**The error tail is shared.** ``SerializeInto`` marks the path and puts
the value under its key, so a property which can fail is a call and a
check instead of twenty-two lines.

    // before, per fallible property
    common::optional<nlohmann::json> json_semantic_id;
    std::tie(
      json_semantic_id,
      error
    ) = SerializeIClass(
      **maybe_semantic_id
    );
    if (error.has_value()) {
      error->path.segments.emplace_front(
        common::make_unique<iteration::PropertySegment>(
          i... (continued)

185 of 202 new or added lines in 1 file covered. (91.58%)

36963 of 42351 relevant lines covered (87.28%)

2.62 hits per line