Function write_union_configured_value

cpp/fory/serialization/union_serializer.h:601–659

template <typename ValueType, typename SpecProvider, int8_t NodeIndex>
void write_union_configured_value(const ValueType &value, WriteContext &ctx,
                                  RefMode ref_mode, bool write_type,
                                  bool has_generics) {
  constexpr FieldNodeKind kind = union_node_kind<SpecProvider, NodeIndex>();
  constexpr FieldScalarKind scalar_kind =
      union_node_scalar<SpecProvider, NodeIndex>();
  static_assert(configured_scalar_kind_matches<ValueType, scalar_kind>(),
                "fory::T typed scalar spec does not match the C++ union case "
                "type");
  if constexpr (is_optional_v<ValueType>) {
    using Inner = typename ValueType::value_type;
    if (!value.has_value()) {
      if (ref_mode != RefMode::None) {
        ctx.write_int8(NULL_FLAG);
      }
      return;
    }
    write_not_null_ref_flag(ctx, ref_mode);
    constexpr int8_t child =
        kind == FieldNodeKind::Inner
            ? union_node_child<SpecProvider, NodeIndex, 0>()
            : NodeIndex;
    write_union_configured_value<Inner, SpecProvider, child>(
        *value, ctx, RefMode::None, false, has_generics);
  } else if constexpr ((is_vector_v<ValueType> || is_list_v<ValueType> ||
                        is_deque_v<ValueType> || is_set_like_v<ValueType>) &&
                       kind == FieldNodeKind::Array) {
    Serializer<ValueType>::write(value, ctx, ref_mode, false, has_generics);
  } else if constexpr ((is_vector_v<ValueType> || is_list_v<ValueType> ||
                        is_deque_v<ValueType> || is_set_like_v<ValueType>) &&
                       (kind == FieldNodeKind::List ||
                        kind == FieldNodeKind::Set)) {
    if constexpr (union_vector_primitive_array_spec<ValueType, SpecProvider,
                                                    NodeIndex>()) {
      Serializer<ValueType>::write(value, ctx, ref_mode, false, has_generics);
    } else {
      write_not_null_ref_flag(ctx, ref_mode);
      constexpr int8_t child = union_node_child<SpecProvider, NodeIndex, 0>();
      write_union_configured_list_data<ValueType, SpecProvider, child>(value,
                                                                       ctx);
    }
  } else if constexpr (is_map_like_v<ValueType> && kind == FieldNodeKind::Map) {
    write_not_null_ref_flag(ctx, ref_mode);
    constexpr int8_t key_child = union_node_child<SpecProvider, NodeIndex, 0>();
    constexpr int8_t value_child =
        union_node_child<SpecProvider, NodeIndex, 1>();
    write_union_configured_map_data<ValueType, SpecProvider, key_child,
                                    value_child>(value, ctx);
  } else if constexpr (kind == FieldNodeKind::Scalar ||
                       union_node_encoding<SpecProvider, NodeIndex>() !=
                           Encoding::Default) {
    write_not_null_ref_flag(ctx, ref_mode);
    write_union_configured_scalar<ValueType, SpecProvider, NodeIndex>(value,
                                                                      ctx);
  } else {
    Serializer<ValueType>::write(value, ctx, ref_mode, write_type,
                                 has_generics);
  }