Function write_single_field

cpp/fory/serialization/struct_serializer.h:2495–2711

/// Helper to write a single field
template <typename T, size_t Index, typename FieldPtrs>
void write_single_field(const T &obj, WriteContext &ctx,
                        const FieldPtrs &field_ptrs, bool has_generics) {
  using Helpers = CompileTimeFieldHelpers<T>;
  const auto field_entry = std::get<Index>(field_ptrs);
  using RawFieldType = meta::FieldRawTypeT<T, decltype(field_entry)>;
  using FieldType = unwrap_field_t<RawFieldType>;

  auto &&field_value = [&]() -> decltype(auto) {
    if constexpr (Helpers::template is_direct_field<Index>()) {
      if constexpr (is_fory_field_v<RawFieldType>) {
        return (obj.*field_entry).value;
      } else {
        return (obj.*field_entry);
      }
    } else {
      return field_value_get(obj, field_entry);
    }
  }();

  constexpr TypeId field_type_id = Serializer<FieldType>::type_id;
  constexpr bool is_primitive_field = is_primitive_type_id(field_type_id);

  // get field metadata from the effective field spec or defaults.
  constexpr bool is_nullable = Helpers::template field_nullable<Index>();
  constexpr bool track_ref = Helpers::template field_track_ref<Index>();
  // Some wrapper types always require ref/null flags in the wire format.
  constexpr bool field_type_is_nullable = is_nullable_v<FieldType>;

  if constexpr (configured_node_has_override<T, Index>()) {
    constexpr RefMode field_ref_mode =
        make_ref_mode(is_nullable || field_type_is_nullable, track_ref);
    constexpr bool is_struct = is_struct_type(field_type_id);
    constexpr bool is_ext = is_ext_type(field_type_id);
    constexpr bool is_polymorphic = field_type_id == TypeId::UNKNOWN;
    constexpr int dynamic_val = Helpers::template field_dynamic_value<Index>();
    constexpr bool polymorphic_write_type =
        (dynamic_val == 1) || (dynamic_val == -1 && is_polymorphic);
    bool write_type = polymorphic_write_type ||
                      ((is_struct || is_ext) && ctx.is_compatible());
    write_configured_value<FieldType, T, Index, 0>(
        field_value, ctx, field_ref_mode, write_type, has_generics);
    return;
  }

  // Special handling for std::optional<uint32_t/uint64_t> with encoding config
  // This must come BEFORE the general primitive check because optional requires
  // ref metadata but we want to use encoding-specific serialization.
  constexpr bool is_encoded_optional_uint =
      ::fory::detail::has_field_config_v<T> &&
      (std::is_same_v<FieldType, std::optional<uint32_t>> ||
       std::is_same_v<FieldType, std::optional<uint64_t>>);
  constexpr bool is_encoded_optional_int =
      ::fory::detail::has_field_config_v<T> &&
      (std::is_same_v<FieldType, std::optional<int32_t>> ||
       std::is_same_v<FieldType, std::optional<int64_t>> ||
       std::is_same_v<FieldType, std::optional<int>> ||
       std::is_same_v<FieldType, std::optional<long long>>);