[C++] Type is var but data is fixed when write `uint32_t`/`uint64_t`.

[ruoruoniao]

Search before asking

• I had searched in the issues and found no similar issues.

Version

Latest

Component(s)

C++

Minimal reproduce step

When use a normal struct with uint32_t, the type id is 0x0C, but write data as 8 bytes like 0x01 0x00 0x00 0x00.

What did you expect to see?

If use 0x0C, the data should be 0x01.

What did you see instead?

I see a comment at Serializer<uint32_t> and Serializer<uint64_t>:

/// uint32_t serializer - uses VAR_UINT32 to match Rust xlang mode
template <> struct Serializer<uint32_t> {

... codes

/// uint64_t serializer - uses VAR_UINT64 to match Rust xlang mode
template <> struct Serializer<uint64_t> {

... codes

But if using a struct, in struct_serializer.h -> write_struct_fields_impl function, it will walk in branch:

  if constexpr (prim_count == total_count) {
    ...codes
  }

So it will use write_primitive_fields_fast function to write data. It will let uint32_t field in fixed_count, so it will walk into branch:

if constexpr (fixed_count > 0 && fixed_bytes > 0) {
    write_fixed_primitive_fields<T>(obj, buffer,
                                    std::make_index_sequence<fixed_count>{});
  }

So maybe let uint32_t as a varint when use FORY_STRUCT?

Anything Else?

No response

Are you willing to submit a PR?

• I'm willing to submit a PR!

[chaokunyang]

If the int32 field is fixed int32, it will go to write_fixed_primitive_fields, otherwise, it wont' go to this function, the field value will still be writtten as varint32

[ruoruoniao]

If the int32 field is fixed int32, it will go to write_fixed_primitive_fields, otherwise, it wont' go to this function, the field value will still be writtten as varint32

No... If it works itself, all is OK, but if in xlang...

//
// Created by MikuSoft on 2026/6/11.
//

#include <fory/serialization/fory.h>
#include <fory/serialization/serializer.h>

#include <fstream>

struct X {
    uint32_t a = 0;
    uint32_t b = 0;
    uint32_t c = 0;
    std::vector<uint32_t> d{};
};

FORY_STRUCT(X, a, b, c, d);


int main(const int argc, char **argv) {
    fory::serialization::Fory fory = fory::serialization::ForyBuilder().xlang(true).track_ref(true).build();
    fory.register_struct<X>("X");
    const auto x = fory.serialize(X{66051, 66051, 66051, {66051, 66051, 66051}});
    if (!x.ok()) {
        return -1;
    }
    std::ofstream file("cxx.bin", std::ios::binary);
    file.write(reinterpret_cast<const char *>(x.value().data()), static_cast<uint32_t>(x.value().size()));
    file.close();

    return 0;
}

import pyfory
from pyfory.annotation import *

from dataclasses import dataclass, field
from typing import List

@dataclass
class X:
    a: UInt32 = 0
    b: UInt32 = 0
    c: UInt32 = 0
    d: List[UInt32] = field(default_factory=list)

"""
This will cause the same error.
@dataclass
class X:
    a: FixedUInt32 = 0
    b: FixedUInt32 = 0
    c: FixedUInt32 = 0
    d: List[FixedUInt32] = field(default_factory=list)
"""

fory = pyfory.Fory(xlang=True, ref=True, strict=True)

fory.register_type(X, typename="X")

with open("cxx.bin", "rb") as f:
    data = fory.deserialize(f.read())
    print(data)

with open("py.bin", "wb") as f:
    f.write(fory.serialize(data))

Python will print:

X(a=3, b=2, c=1, d=[])

As you know, 66051 is 0x01 0x02 0x03. Vector cannot be serialized correct. Also, it cannot convert into c++ by content in py.bin.
You can try yourself.

[ruoruoniao]

In serializer, vector<uint32_t> will copy data into it. But in python, there is all varint data. So it will went wrong at:

// unsigne+_serializer.h

static inline std::vector<uint32_t> read_data(ReadContext &ctx) {
    uint32_t total_bytes = ctx.read_var_uint32(ctx.error());
    if (FORY_PREDICT_FALSE(ctx.has_error())) {
      return std::vector<uint32_t>();
    }

    if (FORY_PREDICT_FALSE(total_bytes > ctx.config().max_binary_size)) {
      ctx.set_error(Error::invalid_data("Binary size exceeds max_binary_size"));
      return std::vector<uint32_t>();
    }

    // HERE!
    if (total_bytes % sizeof(uint32_t) != 0) {
      ctx.set_error(Error::invalid_data("Invalid length: " +
                                        std::to_string(total_bytes)));
      return std::vector<uint32_t>();
    }
    if (FORY_PREDICT_FALSE(total_bytes > ctx.buffer().remaining_size())) {
      ctx.set_error(Error::invalid_data("Invalid length: " +
                                        std::to_string(total_bytes)));
      return std::vector<uint32_t>();
    }
    size_t length = total_bytes / sizeof(uint32_t);
    std::vector<uint32_t> vec(length);
    if (total_bytes > 0) {
      ctx.read_bytes(vec.data(), total_bytes, ctx.error());
    }
    return vec;
  }

Because data is varint, so...

[ruoruoniao]

Or use 0x0B to write fix int. Or use 0x0C to write var int.

[chaokunyang]

This is indeed a bug for unsigned int, let me fix it and release a new version.

Thanks for reporting this issue.