This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git
The following commit(s) were added to refs/heads/main by this push:
new cd8d5c4fc refactor(c++/rust): refine c++ serialize_to API (#3045)
cd8d5c4fc is described below
commit cd8d5c4fcc03360a66597540854626130bcc03a4
Author: Shawn Yang <[email protected]>
AuthorDate: Thu Dec 11 13:38:12 2025 +0800
refactor(c++/rust): refine c++ serialize_to API (#3045)
## Why?
## What does this PR do?
## Related issues
## Does this PR introduce any user-facing change?
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
## Benchmark
---
benchmarks/cpp_benchmark/benchmark.cc | 6 +-
cpp/fory/serialization/fory.h | 24 ++---
docs/guide/cpp/basic-serialization.md | 6 +-
docs/guide/rust/basic-serialization.md | 2 +-
docs/guide/rust/index.md | 2 +-
rust/README.md | 2 +-
rust/fory-core/src/fory.rs | 14 +--
rust/fory/src/lib.rs | 2 +-
rust/tests/tests/compatible/test_basic_type.rs | 102 ++++++++++-----------
rust/tests/tests/compatible/test_struct_enum.rs | 6 +-
rust/tests/tests/test_cross_language.rs | 114 ++++++++++++------------
rust/tests/tests/test_fory.rs | 20 ++---
rust/tests/tests/test_skip_fields.rs | 2 +-
13 files changed, 151 insertions(+), 151 deletions(-)
diff --git a/benchmarks/cpp_benchmark/benchmark.cc
b/benchmarks/cpp_benchmark/benchmark.cc
index c9767ba9b..1e5eaf967 100644
--- a/benchmarks/cpp_benchmark/benchmark.cc
+++ b/benchmarks/cpp_benchmark/benchmark.cc
@@ -441,7 +441,7 @@ static void BM_Fory_Struct_Serialize(benchmark::State
&state) {
for (auto _ : state) {
buffer.WriterIndex(0);
- fory.serialize_to(obj, buffer);
+ fory.serialize_to(buffer, obj);
benchmark::DoNotOptimize(buffer.data());
}
}
@@ -528,7 +528,7 @@ static void BM_Fory_Sample_Serialize(benchmark::State
&state) {
for (auto _ : state) {
buffer.WriterIndex(0);
- auto result = fory.serialize_to(obj, buffer);
+ auto result = fory.serialize_to(buffer, obj);
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(buffer.data());
}
@@ -608,7 +608,7 @@ static void BM_Fory_MediaContent_Serialize(benchmark::State
&state) {
for (auto _ : state) {
buffer.WriterIndex(0);
- auto result = fory.serialize_to(obj, buffer);
+ auto result = fory.serialize_to(buffer, obj);
benchmark::DoNotOptimize(result);
benchmark::DoNotOptimize(buffer.data());
}
diff --git a/cpp/fory/serialization/fory.h b/cpp/fory/serialization/fory.h
index 030fed699..e134b31a3 100644
--- a/cpp/fory/serialization/fory.h
+++ b/cpp/fory/serialization/fory.h
@@ -422,12 +422,12 @@ public:
/// Serialize an object to an existing Buffer (fastest path).
///
/// @tparam T The type of object to serialize.
- /// @param obj The object to serialize.
/// @param buffer The buffer to write to.
+ /// @param obj The object to serialize.
/// @return Number of bytes written, or error.
template <typename T>
- FORY_ALWAYS_INLINE Result<size_t, Error> serialize_to(const T &obj,
- Buffer &buffer) {
+ FORY_ALWAYS_INLINE Result<size_t, Error> serialize_to(Buffer &buffer,
+ const T &obj) {
if (FORY_PREDICT_FALSE(!finalized_)) {
ensure_finalized();
}
@@ -441,18 +441,18 @@ public:
/// fit the serialized data.
///
/// @tparam T The type of object to serialize.
- /// @param obj The object to serialize.
/// @param output The vector to append to.
+ /// @param obj The object to serialize.
/// @return Number of bytes written, or error.
template <typename T>
- Result<size_t, Error> serialize_to(const T &obj,
- std::vector<uint8_t> &output) {
+ Result<size_t, Error> serialize_to(std::vector<uint8_t> &output,
+ const T &obj) {
// Wrap the output vector in a Buffer for zero-copy serialization
// writer_index starts at output.size() for appending
Buffer buffer(output);
// Forward to Buffer version
- auto result = serialize_to(obj, buffer);
+ auto result = serialize_to(buffer, obj);
// Resize vector to actual written size
output.resize(buffer.writer_index());
@@ -713,16 +713,16 @@ public:
}
template <typename T>
- Result<size_t, Error> serialize_to(const T &obj, Buffer &buffer) {
+ Result<size_t, Error> serialize_to(Buffer &buffer, const T &obj) {
auto fory_handle = fory_pool_.acquire();
- return fory_handle->serialize_to(obj, buffer);
+ return fory_handle->serialize_to(buffer, obj);
}
template <typename T>
- Result<size_t, Error> serialize_to(const T &obj,
- std::vector<uint8_t> &output) {
+ Result<size_t, Error> serialize_to(std::vector<uint8_t> &output,
+ const T &obj) {
auto fory_handle = fory_pool_.acquire();
- return fory_handle->serialize_to(obj, output);
+ return fory_handle->serialize_to(output, obj);
}
template <typename T>
diff --git a/docs/guide/cpp/basic-serialization.md
b/docs/guide/cpp/basic-serialization.md
index 83182495e..5d24a926d 100644
--- a/docs/guide/cpp/basic-serialization.md
+++ b/docs/guide/cpp/basic-serialization.md
@@ -114,7 +114,7 @@ if (result.ok()) {
```cpp
// Serialize to existing Buffer (fastest path)
Buffer buffer;
-auto result = fory.serialize_to(obj, buffer);
+auto result = fory.serialize_to(buffer, obj);
if (result.ok()) {
size_t bytes_written = result.value();
// buffer now contains serialized data
@@ -122,7 +122,7 @@ if (result.ok()) {
// Serialize to existing vector (zero-copy)
std::vector<uint8_t> output;
-auto result = fory.serialize_to(obj, output);
+auto result = fory.serialize_to(output, obj);
if (result.ok()) {
size_t bytes_written = result.value();
// output now contains serialized data
@@ -225,7 +225,7 @@ fory.register_struct<Outer>(2);
## Performance Tips
-- **Buffer Reuse**: Use `serialize_to(obj, buffer)` with pre-allocated buffers
+- **Buffer Reuse**: Use `serialize_to(buffer, obj)` with pre-allocated buffers
- **Pre-registration**: Register all types before serialization starts
- **Single-Threaded**: Use `build()` instead of `build_thread_safe()` when
possible
- **Disable Tracking**: Use `track_ref(false)` when references aren't needed
diff --git a/docs/guide/rust/basic-serialization.md
b/docs/guide/rust/basic-serialization.md
index e62c2bcc3..0c5b622ee 100644
--- a/docs/guide/rust/basic-serialization.md
+++ b/docs/guide/rust/basic-serialization.md
@@ -144,7 +144,7 @@ let decoded: MyStruct = fory.deserialize(&bytes)?;
// Serialize to existing buffer
let mut buf: Vec<u8> = vec![];
-fory.serialize_to(&obj, &mut buf)?;
+fory.serialize_to(&mut buf, &obj)?;
// Deserialize from reader
let mut reader = Reader::new(&buf);
diff --git a/docs/guide/rust/index.md b/docs/guide/rust/index.md
index 522fbf3c0..fe4ba0ae5 100644
--- a/docs/guide/rust/index.md
+++ b/docs/guide/rust/index.md
@@ -81,7 +81,7 @@ fn main() -> Result<(), Error> {
// Serialize to specified buffer
let mut buf: Vec<u8> = vec![];
- fory.serialize_to(&user, &mut buf)?;
+ fory.serialize_to(&mut buf, &user)?;
// Deserialize from specified buffer
let mut reader = Reader::new(&buf);
let decoded: User = fory.deserialize_from(&mut reader)?;
diff --git a/rust/README.md b/rust/README.md
index f0bef3569..d84bfcebe 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -66,7 +66,7 @@ fn main() -> Result<(), Error> {
// Serialize to specified buffer
let mut buf: Vec<u8> = vec![];
- fory.serialize_to(&user, &mut buf)?;
+ fory.serialize_to(&mut buf, &user)?;
// Deserialize from specified buffer
let mut reader = Reader::new(&buf);
let decoded: User = fory.deserialize_from(&mut reader)?;
diff --git a/rust/fory-core/src/fory.rs b/rust/fory-core/src/fory.rs
index 6816e4d40..a0081f8a6 100644
--- a/rust/fory-core/src/fory.rs
+++ b/rust/fory-core/src/fory.rs
@@ -401,9 +401,9 @@ impl Fory {
///
/// # Arguments
///
- /// * `record` - A reference to the value to serialize.
/// * `buf` - A mutable reference to the byte buffer to append the
serialized data to.
/// The buffer will be resized as needed during serialization.
+ /// * `record` - A reference to the value to serialize.
///
/// # Returns
///
@@ -431,7 +431,7 @@ impl Fory {
/// let point = Point { x: 1, y: 2 };
///
/// let mut buf = Vec::new();
- /// let bytes_written = fory.serialize_to(&point, &mut buf).unwrap();
+ /// let bytes_written = fory.serialize_to(&mut buf, &point).unwrap();
/// assert_eq!(bytes_written, buf.len());
/// ```
///
@@ -454,11 +454,11 @@ impl Fory {
/// let mut buf = Vec::new();
///
/// // First serialization
- /// let len1 = fory.serialize_to(&p1, &mut buf).unwrap();
+ /// let len1 = fory.serialize_to(&mut buf, &p1).unwrap();
/// let offset1 = buf.len();
///
/// // Second serialization - appends to existing data
- /// let len2 = fory.serialize_to(&p2, &mut buf).unwrap();
+ /// let len2 = fory.serialize_to(&mut buf, &p2).unwrap();
/// let offset2 = buf.len();
///
/// assert_eq!(offset1, len1);
@@ -495,20 +495,20 @@ impl Fory {
/// buf.resize(16, 0); // Set length to 16 to append the write, capacity
stays 1024
///
/// let initial_capacity = buf.capacity();
- /// fory.serialize_to(&point, &mut buf).unwrap();
+ /// fory.serialize_to(&mut buf, &point).unwrap();
///
/// // Reset to smaller size to append the write - capacity unchanged
/// buf.resize(16, 0);
/// assert_eq!(buf.capacity(), initial_capacity); // Capacity not shrunk
///
/// // Reuse buffer efficiently without reallocation
- /// fory.serialize_to(&point, &mut buf).unwrap();
+ /// fory.serialize_to(&mut buf, &point).unwrap();
/// assert_eq!(buf.capacity(), initial_capacity); // Still no reallocation
/// ```
pub fn serialize_to<T: Serializer>(
&self,
- record: &T,
buf: &mut Vec<u8>,
+ record: &T,
) -> Result<usize, Error> {
let start = buf.len();
self.with_write_context(|context| {
diff --git a/rust/fory/src/lib.rs b/rust/fory/src/lib.rs
index 1997e3bb9..41f641ff1 100644
--- a/rust/fory/src/lib.rs
+++ b/rust/fory/src/lib.rs
@@ -83,7 +83,7 @@
//!
//! // Serialize to specified buffer and deserialize from it
//! let mut buf: Vec<u8> = vec![];
-//! fory.serialize_to(&user, &mut buf)?;
+//! fory.serialize_to(&mut buf, &user)?;
//! let mut reader = Reader::new(&buf);
//! let decoded: User = fory.deserialize_from(&mut reader)?;
//! assert_eq!(user, decoded);
diff --git a/rust/tests/tests/compatible/test_basic_type.rs
b/rust/tests/tests/compatible/test_basic_type.rs
index 02f8abbf2..4f08fee64 100644
--- a/rust/tests/tests/compatible/test_basic_type.rs
+++ b/rust/tests/tests/compatible/test_basic_type.rs
@@ -44,82 +44,82 @@ const FLOAT64_ARRAY: [f64; 1] = [53.0];
fn serialize_non_null(fory: &Fory) -> Vec<u8> {
let mut buf = Vec::new();
- fory.serialize_to(&BOOL_VAL, &mut buf).unwrap();
- fory.serialize_to(&I8_VAL, &mut buf).unwrap();
- fory.serialize_to(&I16_VAL, &mut buf).unwrap();
- fory.serialize_to(&I32_VAL, &mut buf).unwrap();
- fory.serialize_to(&I64_VAL, &mut buf).unwrap();
- fory.serialize_to(&F32_VAL, &mut buf).unwrap();
- fory.serialize_to(&F64_VAL, &mut buf).unwrap();
- fory.serialize_to(&STR_LATIN1_VAL.to_string(), &mut buf)
+ fory.serialize_to(&mut buf, &BOOL_VAL).unwrap();
+ fory.serialize_to(&mut buf, &I8_VAL).unwrap();
+ fory.serialize_to(&mut buf, &I16_VAL).unwrap();
+ fory.serialize_to(&mut buf, &I32_VAL).unwrap();
+ fory.serialize_to(&mut buf, &I64_VAL).unwrap();
+ fory.serialize_to(&mut buf, &F32_VAL).unwrap();
+ fory.serialize_to(&mut buf, &F64_VAL).unwrap();
+ fory.serialize_to(&mut buf, &STR_LATIN1_VAL.to_string())
.unwrap();
- fory.serialize_to(&LOCAL_DATE_VAL, &mut buf).unwrap();
- fory.serialize_to(&TIMESTAMP_VAL, &mut buf).unwrap();
- fory.serialize_to(&BOOL_ARRAY.to_vec(), &mut buf).unwrap();
- fory.serialize_to(&INT8_ARRAY.to_vec(), &mut buf).unwrap();
- fory.serialize_to(&INT16_ARRAY.to_vec(), &mut buf).unwrap();
- fory.serialize_to(&INT32_ARRAY.to_vec(), &mut buf).unwrap();
- fory.serialize_to(&INT64_ARRAY.to_vec(), &mut buf).unwrap();
- fory.serialize_to(&FLOAT32_ARRAY.to_vec(), &mut buf)
+ fory.serialize_to(&mut buf, &LOCAL_DATE_VAL).unwrap();
+ fory.serialize_to(&mut buf, &TIMESTAMP_VAL).unwrap();
+ fory.serialize_to(&mut buf, &BOOL_ARRAY.to_vec()).unwrap();
+ fory.serialize_to(&mut buf, &INT8_ARRAY.to_vec()).unwrap();
+ fory.serialize_to(&mut buf, &INT16_ARRAY.to_vec()).unwrap();
+ fory.serialize_to(&mut buf, &INT32_ARRAY.to_vec()).unwrap();
+ fory.serialize_to(&mut buf, &INT64_ARRAY.to_vec()).unwrap();
+ fory.serialize_to(&mut buf, &FLOAT32_ARRAY.to_vec())
.unwrap();
- fory.serialize_to(&FLOAT64_ARRAY.to_vec(), &mut buf)
+ fory.serialize_to(&mut buf, &FLOAT64_ARRAY.to_vec())
.unwrap();
buf
}
fn serialize_nullable(fory: &Fory) -> Vec<u8> {
let mut buf = Vec::new();
- fory.serialize_to(&Some(BOOL_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(I8_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(I16_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(I32_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(I64_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(F32_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(F64_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(STR_LATIN1_VAL.to_string()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(BOOL_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(I8_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(I16_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(I32_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(I64_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(F32_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(F64_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(STR_LATIN1_VAL.to_string()))
.unwrap();
- fory.serialize_to(&Some(LOCAL_DATE_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(TIMESTAMP_VAL), &mut buf).unwrap();
- fory.serialize_to(&Some(BOOL_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(LOCAL_DATE_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(TIMESTAMP_VAL)).unwrap();
+ fory.serialize_to(&mut buf, &Some(BOOL_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(INT8_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(INT8_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(INT16_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(INT16_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(INT32_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(INT32_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(INT64_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(INT64_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(FLOAT32_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(FLOAT32_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Some(FLOAT64_ARRAY.to_vec()), &mut buf)
+ fory.serialize_to(&mut buf, &Some(FLOAT64_ARRAY.to_vec()))
.unwrap();
- fory.serialize_to(&Option::<bool>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<i8>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<i16>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<i32>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<i64>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<f32>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<f64>::None, &mut buf).unwrap();
- fory.serialize_to(&Option::<String>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<bool>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<i8>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<i16>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<i32>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<i64>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<f32>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<f64>::None).unwrap();
+ fory.serialize_to(&mut buf, &Option::<String>::None)
.unwrap();
- fory.serialize_to(&Option::<NaiveDate>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<NaiveDate>::None)
.unwrap();
- fory.serialize_to(&Option::<NaiveDateTime>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<NaiveDateTime>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<bool>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<bool>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<i8>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<i8>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<i16>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<i16>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<i32>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<i32>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<i64>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<i64>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<f32>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<f32>>::None)
.unwrap();
- fory.serialize_to(&Option::<Vec<f64>>::None, &mut buf)
+ fory.serialize_to(&mut buf, &Option::<Vec<f64>>::None)
.unwrap();
buf
}
diff --git a/rust/tests/tests/compatible/test_struct_enum.rs
b/rust/tests/tests/compatible/test_struct_enum.rs
index ececef218..052c7439f 100644
--- a/rust/tests/tests/compatible/test_struct_enum.rs
+++ b/rust/tests/tests/compatible/test_struct_enum.rs
@@ -93,9 +93,9 @@ fn simple_write_continuous() {
last: 44,
};
let mut buffer = vec![];
- fory.serialize_to(&animal, &mut buffer).unwrap();
- fory.serialize_to(&animal, &mut buffer).unwrap();
- fory.serialize_to(&animal, &mut buffer).unwrap();
+ fory.serialize_to(&mut buffer, &animal).unwrap();
+ fory.serialize_to(&mut buffer, &animal).unwrap();
+ fory.serialize_to(&mut buffer, &animal).unwrap();
let reader = &mut Reader::new(buffer.as_slice());
let animal1: Animal1 = fory.deserialize_from(reader).unwrap();
diff --git a/rust/tests/tests/test_cross_language.rs
b/rust/tests/tests/test_cross_language.rs
index c092a116f..2afc3f470 100644
--- a/rust/tests/tests/test_cross_language.rs
+++ b/rust/tests/tests/test_cross_language.rs
@@ -260,7 +260,7 @@ fn test_string_serializer() {
let fory = Fory::default().compatible(true).xlang(true);
let mut buf = Vec::new();
for s in &test_strings {
- fory.serialize_to(s, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, s).unwrap();
}
fs::write(&data_file_path, buf).unwrap();
}
@@ -320,34 +320,34 @@ fn test_cross_language_serializer() {
assert_de!(fory, reader, Color, color);
let mut buf = Vec::new();
- fory.serialize_to(&true, &mut buf).unwrap();
- fory.serialize_to(&false, &mut buf).unwrap();
- fory.serialize_to(&-1, &mut buf).unwrap();
- fory.serialize_to(&i8::MAX, &mut buf).unwrap();
- fory.serialize_to(&i8::MIN, &mut buf).unwrap();
- fory.serialize_to(&i16::MAX, &mut buf).unwrap();
- fory.serialize_to(&i16::MIN, &mut buf).unwrap();
- fory.serialize_to(&i32::MAX, &mut buf).unwrap();
- fory.serialize_to(&i32::MIN, &mut buf).unwrap();
- fory.serialize_to(&i64::MAX, &mut buf).unwrap();
- fory.serialize_to(&i64::MIN, &mut buf).unwrap();
- fory.serialize_to(&-1f32, &mut buf).unwrap();
- fory.serialize_to(&-1f64, &mut buf).unwrap();
- fory.serialize_to(&"str".to_string(), &mut buf).unwrap();
- fory.serialize_to(&day, &mut buf).unwrap();
- fory.serialize_to(&instant, &mut buf).unwrap();
- fory.serialize_to(&vec![true, false], &mut buf).unwrap();
- fory.serialize_to(&vec![1, i8::MAX as u8], &mut buf)
+ fory.serialize_to(&mut buf, &true).unwrap();
+ fory.serialize_to(&mut buf, &false).unwrap();
+ fory.serialize_to(&mut buf, &-1).unwrap();
+ fory.serialize_to(&mut buf, &i8::MAX).unwrap();
+ fory.serialize_to(&mut buf, &i8::MIN).unwrap();
+ fory.serialize_to(&mut buf, &i16::MAX).unwrap();
+ fory.serialize_to(&mut buf, &i16::MIN).unwrap();
+ fory.serialize_to(&mut buf, &i32::MAX).unwrap();
+ fory.serialize_to(&mut buf, &i32::MIN).unwrap();
+ fory.serialize_to(&mut buf, &i64::MAX).unwrap();
+ fory.serialize_to(&mut buf, &i64::MIN).unwrap();
+ fory.serialize_to(&mut buf, &-1f32).unwrap();
+ fory.serialize_to(&mut buf, &-1f64).unwrap();
+ fory.serialize_to(&mut buf, &"str".to_string()).unwrap();
+ fory.serialize_to(&mut buf, &day).unwrap();
+ fory.serialize_to(&mut buf, &instant).unwrap();
+ fory.serialize_to(&mut buf, &vec![true, false]).unwrap();
+ fory.serialize_to(&mut buf, &vec![1, i8::MAX as u8])
.unwrap();
- fory.serialize_to(&vec![1, i16::MAX], &mut buf).unwrap();
- fory.serialize_to(&vec![1, i32::MAX], &mut buf).unwrap();
- fory.serialize_to(&vec![1, i64::MAX], &mut buf).unwrap();
- fory.serialize_to(&vec![1f32, 2f32], &mut buf).unwrap();
- fory.serialize_to(&vec![1f64, 2f64], &mut buf).unwrap();
- fory.serialize_to(&str_list, &mut buf).unwrap();
- fory.serialize_to(&str_set, &mut buf).unwrap();
- fory.serialize_to(&str_map, &mut buf).unwrap();
- fory.serialize_to(&color, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &vec![1, i16::MAX]).unwrap();
+ fory.serialize_to(&mut buf, &vec![1, i32::MAX]).unwrap();
+ fory.serialize_to(&mut buf, &vec![1, i64::MAX]).unwrap();
+ fory.serialize_to(&mut buf, &vec![1f32, 2f32]).unwrap();
+ fory.serialize_to(&mut buf, &vec![1f64, 2f64]).unwrap();
+ fory.serialize_to(&mut buf, &str_list).unwrap();
+ fory.serialize_to(&mut buf, &str_set).unwrap();
+ fory.serialize_to(&mut buf, &str_map).unwrap();
+ fory.serialize_to(&mut buf, &color).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -449,10 +449,10 @@ fn test_list() {
assert_eq!(remote_item_list2, item_list2);
let mut buf = Vec::new();
- fory.serialize_to(&remote_str_list, &mut buf).unwrap();
- fory.serialize_to(&remote_str_list2, &mut buf).unwrap();
- fory.serialize_to(&remote_item_list, &mut buf).unwrap();
- fory.serialize_to(&remote_item_list2, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &remote_str_list).unwrap();
+ fory.serialize_to(&mut buf, &remote_str_list2).unwrap();
+ fory.serialize_to(&mut buf, &remote_item_list).unwrap();
+ fory.serialize_to(&mut buf, &remote_item_list2).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -565,13 +565,13 @@ fn test_integer() {
assert_eq!(remote_f6, f6);
let mut buf = Vec::new();
- fory.serialize_to(&remote_item2, &mut buf).unwrap();
- fory.serialize_to(&remote_f1, &mut buf).unwrap();
- fory.serialize_to(&remote_f2, &mut buf).unwrap();
- fory.serialize_to(&remote_f3, &mut buf).unwrap();
- fory.serialize_to(&remote_f4, &mut buf).unwrap();
- fory.serialize_to(&remote_f5, &mut buf).unwrap();
- fory.serialize_to(&remote_f6, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &remote_item2).unwrap();
+ fory.serialize_to(&mut buf, &remote_f1).unwrap();
+ fory.serialize_to(&mut buf, &remote_f2).unwrap();
+ fory.serialize_to(&mut buf, &remote_f3).unwrap();
+ fory.serialize_to(&mut buf, &remote_f4).unwrap();
+ fory.serialize_to(&mut buf, &remote_f5).unwrap();
+ fory.serialize_to(&mut buf, &remote_f6).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -695,13 +695,13 @@ fn test_consistent_named() {
}
let mut buf = Vec::new();
for _ in 0..3 {
- fory.serialize_to(&color, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &color).unwrap();
}
for _ in 0..3 {
- fory.serialize_to(&my_struct, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &my_struct).unwrap();
}
for _ in 0..3 {
- fory.serialize_to(&my_ext, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &my_ext).unwrap();
}
fs::write(&data_file_path, buf).unwrap();
}
@@ -774,9 +774,9 @@ fn test_item() {
assert_eq!(remote_item3, item3);
let mut buf = Vec::new();
- fory.serialize_to(&remote_item1, &mut buf).unwrap();
- fory.serialize_to(&remote_item2, &mut buf).unwrap();
- fory.serialize_to(&remote_item3, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &remote_item1).unwrap();
+ fory.serialize_to(&mut buf, &remote_item2).unwrap();
+ fory.serialize_to(&mut buf, &remote_item3).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -800,10 +800,10 @@ fn test_color() {
assert_eq!(remote_white, Color::White);
let mut buf = Vec::new();
- fory.serialize_to(&Color::Green, &mut buf).unwrap();
- fory.serialize_to(&Color::Red, &mut buf).unwrap();
- fory.serialize_to(&Color::Blue, &mut buf).unwrap();
- fory.serialize_to(&Color::White, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &Color::Green).unwrap();
+ fory.serialize_to(&mut buf, &Color::Red).unwrap();
+ fory.serialize_to(&mut buf, &Color::Blue).unwrap();
+ fory.serialize_to(&mut buf, &Color::White).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -834,8 +834,8 @@ fn test_struct_with_list() {
assert_eq!(remote_struct2, struct2);
let mut buf = Vec::new();
- fory.serialize_to(&remote_struct1, &mut buf).unwrap();
- fory.serialize_to(&remote_struct2, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &remote_struct1).unwrap();
+ fory.serialize_to(&mut buf, &remote_struct2).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -868,8 +868,8 @@ fn test_struct_with_map() {
assert_eq!(remote_struct2, struct2);
let mut buf = Vec::new();
- fory.serialize_to(&remote_struct1, &mut buf).unwrap();
- fory.serialize_to(&remote_struct2, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &remote_struct1).unwrap();
+ fory.serialize_to(&mut buf, &remote_struct2).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -947,8 +947,8 @@ fn test_polymorphic_list() {
// Write back
let mut buf = Vec::new();
- fory.serialize_to(&animals, &mut buf).unwrap();
- fory.serialize_to(&holder, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &animals).unwrap();
+ fory.serialize_to(&mut buf, &holder).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
@@ -1007,7 +1007,7 @@ fn test_polymorphic_map() {
// Write back
let mut buf = Vec::new();
- fory.serialize_to(&animal_map, &mut buf).unwrap();
- fory.serialize_to(&holder, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &animal_map).unwrap();
+ fory.serialize_to(&mut buf, &holder).unwrap();
fs::write(&data_file_path, buf).unwrap();
}
diff --git a/rust/tests/tests/test_fory.rs b/rust/tests/tests/test_fory.rs
index d8551a803..fc7096c35 100644
--- a/rust/tests/tests/test_fory.rs
+++ b/rust/tests/tests/test_fory.rs
@@ -63,12 +63,12 @@ fn test_serialize_to_appends_bytes() {
let expected_second = fory.serialize(&p2).unwrap();
let mut buf = Vec::new();
- let len_first = fory.serialize_to(&p1, &mut buf).unwrap();
+ let len_first = fory.serialize_to(&mut buf, &p1).unwrap();
assert_eq!(len_first, expected_first.len());
assert_eq!(buf.len(), len_first);
assert_eq!(&buf[..len_first], &expected_first);
- let len_second = fory.serialize_to(&p2, &mut buf).unwrap();
+ let len_second = fory.serialize_to(&mut buf, &p2).unwrap();
assert_eq!(len_second, expected_second.len());
assert_eq!(buf.len(), len_first + len_second);
assert_eq!(&buf[len_first..], &expected_second);
@@ -96,7 +96,7 @@ fn test_serialize_to_detailed() {
// Test 1: Basic serialization to empty buffer
let p1 = Point { x: 10, y: 20 };
let mut buf = Vec::new();
- let len1 = fory.serialize_to(&p1, &mut buf).unwrap();
+ let len1 = fory.serialize_to(&mut buf, &p1).unwrap();
assert_eq!(len1, buf.len());
let deserialized1: Point = fory.deserialize_from(&mut
Reader::new(&buf)).unwrap();
assert_eq!(p1, deserialized1);
@@ -106,9 +106,9 @@ fn test_serialize_to_detailed() {
let p3 = Point { x: 0, y: 0 };
buf.clear();
- let len2_first = fory.serialize_to(&p2, &mut buf).unwrap();
+ let len2_first = fory.serialize_to(&mut buf, &p2).unwrap();
let offset1 = buf.len();
- let len2_second = fory.serialize_to(&p3, &mut buf).unwrap();
+ let len2_second = fory.serialize_to(&mut buf, &p3).unwrap();
let offset2 = buf.len();
assert_eq!(offset1, len2_first);
@@ -129,7 +129,7 @@ fn test_serialize_to_detailed() {
};
buf.clear();
- let len3 = fory.serialize_to(&line, &mut buf).unwrap();
+ let len3 = fory.serialize_to(&mut buf, &line).unwrap();
assert_eq!(len3, buf.len());
let deserialized_line: Line = fory.deserialize_from(&mut
Reader::new(&buf)).unwrap();
assert_eq!(line, deserialized_line);
@@ -143,7 +143,7 @@ fn test_serialize_to_detailed() {
let header_size = buf.len();
// Serialize data after header
- let data_len = fory.serialize_to(&p4, &mut buf).unwrap();
+ let data_len = fory.serialize_to(&mut buf, &p4).unwrap();
// Write the data length into the header
buf[0..8].copy_from_slice(&(data_len as u64).to_le_bytes());
@@ -164,14 +164,14 @@ fn test_serialize_to_detailed() {
buf_with_capacity.resize(16, 0);
let initial_capacity = buf_with_capacity.capacity();
- fory.serialize_to(&p1, &mut buf_with_capacity).unwrap();
+ fory.serialize_to(&mut buf_with_capacity, &p1).unwrap();
// Reset to smaller size - capacity should remain unchanged
buf_with_capacity.resize(16, 0);
assert_eq!(buf_with_capacity.capacity(), initial_capacity);
// Serialize again - should not reallocate
- fory.serialize_to(&p2, &mut buf_with_capacity).unwrap();
+ fory.serialize_to(&mut buf_with_capacity, &p2).unwrap();
assert_eq!(buf_with_capacity.capacity(), initial_capacity);
// Test 6: Serializing many objects sequentially
@@ -185,7 +185,7 @@ fn test_serialize_to_detailed() {
];
for point in &points {
- fory.serialize_to(point, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, point).unwrap();
}
// Deserialize all objects and verify using a single reader
diff --git a/rust/tests/tests/test_skip_fields.rs
b/rust/tests/tests/test_skip_fields.rs
index 00e8e4949..9a9c43059 100644
--- a/rust/tests/tests/test_skip_fields.rs
+++ b/rust/tests/tests/test_skip_fields.rs
@@ -98,7 +98,7 @@ fn test_basic_skip_functionality() {
assert_eq!(decoded.skipped_field, String::default());
let mut buf: Vec<u8> = vec![];
- fory.serialize_to(&original, &mut buf).unwrap();
+ fory.serialize_to(&mut buf, &original).unwrap();
let mut reader = Reader::new(&buf);
let decoded: TestSkipFields = fory.deserialize_from(&mut reader).unwrap();
assert_eq!(original.serialized_field, decoded.serialized_field);
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
