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 3c9c999c0 refactor(rust): move Fory configuration to builder (#3593)
3c9c999c0 is described below
commit 3c9c999c07278a5aa630cc1514fc1b81595fe8fb
Author: Shawn Yang <[email protected]>
AuthorDate: Mon Apr 20 20:52:12 2026 +0800
refactor(rust): move Fory configuration to builder (#3593)
## Why?
## What does this PR do?
## Related issues
## AI Contribution Checklist
- [ ] Substantial AI assistance was used in this PR: `yes` / `no`
- [ ] If `yes`, I included a completed [AI Contribution
Checklist](https://github.com/apache/fory/blob/main/AI_POLICY.md#9-contributor-checklist-for-ai-assisted-prs)
in this PR description and the required `AI Usage Disclosure`.
- [ ] If `yes`, my PR description includes the required `ai_review`
summary and screenshot evidence of the final clean AI review results
from both fresh reviewers on the current PR diff or current HEAD after
the latest code changes.
## 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
---
README.md | 2 +-
compiler/fory_compiler/generators/rust.py | 5 +-
docs/guide/python/cross-language.md | 4 +-
docs/guide/rust/configuration.md | 20 +--
docs/guide/rust/cross-language.md | 12 +-
docs/guide/rust/polymorphism.md | 4 +-
docs/guide/rust/schema-evolution.md | 6 +-
docs/guide/rust/troubleshooting.md | 2 +-
docs/guide/rust/type-registration.md | 4 +-
docs/guide/xlang/field-reference-tracking.md | 6 +-
docs/guide/xlang/getting-started.md | 4 +-
docs/guide/xlang/serialization.md | 4 +-
.../idl_tests/rust/tests/idl_roundtrip.rs | 14 +-
rust/README.md | 10 +-
rust/fory-core/src/fory.rs | 174 +++++++++++++--------
rust/fory-core/src/lib.rs | 6 +-
rust/fory-core/src/serializer/trait_object.rs | 2 +-
rust/fory-core/src/serializer/weak.rs | 4 +-
rust/fory/src/lib.rs | 30 ++--
rust/tests/tests/compatible/test_basic_type.rs | 6 +-
rust/tests/tests/compatible/test_container.rs | 22 +--
rust/tests/tests/compatible/test_struct.rs | 46 +++---
rust/tests/tests/compatible/test_struct_enum.rs | 44 +++---
rust/tests/tests/test_array.rs | 4 +-
rust/tests/tests/test_collection.rs | 2 +-
rust/tests/tests/test_cross_language.rs | 114 ++++++++------
rust/tests/tests/test_debug.rs | 2 +-
rust/tests/tests/test_enum.rs | 12 +-
rust/tests/tests/test_enum_compatible.rs | 34 ++--
rust/tests/tests/test_ext.rs | 2 +-
rust/tests/tests/test_field_meta.rs | 22 +--
rust/tests/tests/test_fory.rs | 7 +-
rust/tests/tests/test_list.rs | 2 +-
rust/tests/tests/test_map.rs | 4 +-
rust/tests/tests/test_max_dyn_depth.rs | 7 +-
rust/tests/tests/test_one_struct.rs | 4 +-
rust/tests/tests/test_rc_arc_trait_object.rs | 2 +-
rust/tests/tests/test_simple_struct.rs | 25 +--
rust/tests/tests/test_skip_fields.rs | 4 +-
rust/tests/tests/test_trait_object.rs | 2 +-
rust/tests/tests/test_tuple.rs | 6 +-
rust/tests/tests/test_tuple_compatible.rs | 64 ++++----
rust/tests/tests/test_tuple_struct.rs | 18 +--
rust/tests/tests/test_unsigned.rs | 24 +--
rust/tests/tests/test_weak.rs | 18 +--
45 files changed, 436 insertions(+), 374 deletions(-)
diff --git a/README.md b/README.md
index a9e5104fb..2d2bd8fc5 100644
--- a/README.md
+++ b/README.md
@@ -573,7 +573,7 @@ struct Person {
}
fn main() -> Result<(), Error> {
- let mut fory = Fory::default().xlang(true);
+ let mut fory = Fory::builder().xlang(true).build();
fory.register::<Person>(1)?;
// fory.register_by_name::<Person>("example.Person")?;
let person = Person {
diff --git a/compiler/fory_compiler/generators/rust.py
b/compiler/fory_compiler/generators/rust.py
index 75752face..f9c8ae852 100644
--- a/compiler/fory_compiler/generators/rust.py
+++ b/compiler/fory_compiler/generators/rust.py
@@ -879,10 +879,11 @@ class RustGenerator(BaseGenerator):
lines.append(" pub(super) fn get_fory() -> &'static Fory {")
lines.append(" static FORY: OnceLock<Fory> = OnceLock::new();")
lines.append(" FORY.get_or_init(|| {")
- lines.append(" let mut fory = Fory::default()")
+ lines.append(" let mut fory = Fory::builder()")
lines.append(" .xlang(true)")
lines.append(" .track_ref(true)")
- lines.append(" .compatible(true);")
+ lines.append(" .compatible(true)")
+ lines.append(" .build();")
for module in self._collect_imported_modules():
lines.append(
f' crate::{module}::register_types(&mut
fory).expect("failed to register fory types");'
diff --git a/docs/guide/python/cross-language.md
b/docs/guide/python/cross-language.md
index 0a75e0581..b5b96f5ca 100644
--- a/docs/guide/python/cross-language.md
+++ b/docs/guide/python/cross-language.md
@@ -85,9 +85,9 @@ struct Person {
age: i32,
}
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
fory.register_by_namespace::<Person>("example", "Person");
let person: Person = fory.deserialize(&binary_data)?;
diff --git a/docs/guide/rust/configuration.md b/docs/guide/rust/configuration.md
index 52d741472..dd6435ee3 100644
--- a/docs/guide/rust/configuration.md
+++ b/docs/guide/rust/configuration.md
@@ -38,7 +38,7 @@ let fory = Fory::default(); // SchemaConsistent by default
Allows independent schema evolution:
```rust
-let fory = Fory::default().compatible(true);
+let fory = Fory::builder().compatible(true).build();
```
## Configuration
@@ -56,7 +56,7 @@ let fory = Fory::default(); // max_dyn_depth = 5
**Custom depth limit:**
```rust
-let fory = Fory::default().max_dyn_depth(10); // Allow up to 10 levels
+let fory = Fory::builder().max_dyn_depth(10).build(); // Allow up to 10 levels
```
**When to adjust:**
@@ -79,9 +79,9 @@ Note: Static data types (non-dynamic types) are secure by
nature and not subject
Enable cross-language serialization:
```rust
-let fory = Fory::default()
+let fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
```
## Builder Pattern
@@ -93,21 +93,21 @@ use fory::Fory;
let fory = Fory::default();
// Compatible mode for schema evolution
-let fory = Fory::default().compatible(true);
+let fory = Fory::builder().compatible(true).build();
// Cross-language mode
-let fory = Fory::default()
+let fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
// Custom depth limit
-let fory = Fory::default().max_dyn_depth(10);
+let fory = Fory::builder().max_dyn_depth(10).build();
// Combined configuration
-let fory = Fory::default()
+let fory = Fory::builder()
.compatible(true)
.xlang(true)
- .max_dyn_depth(10);
+ .max_dyn_depth(10).build();
```
## Configuration Summary
diff --git a/docs/guide/rust/cross-language.md
b/docs/guide/rust/cross-language.md
index fb0ff5377..dac48ec6a 100644
--- a/docs/guide/rust/cross-language.md
+++ b/docs/guide/rust/cross-language.md
@@ -27,9 +27,9 @@ Apache Fory™ supports seamless data exchange across multiple
languages includi
use fory::Fory;
// Enable cross-language mode
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
// Register types with consistent IDs across languages
fory.register::<MyStruct>(100);
@@ -45,9 +45,9 @@ fory.register_by_namespace::<MyStruct>("com.example",
"MyStruct");
For fast, compact serialization with consistent IDs across languages:
```rust
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
fory.register::<User>(100); // Same ID in Java, Python, etc.
```
@@ -74,9 +74,9 @@ struct Person {
age: i32,
}
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
fory.register::<Person>(100);
diff --git a/docs/guide/rust/polymorphism.md b/docs/guide/rust/polymorphism.md
index 80d2bb2c0..2afff965d 100644
--- a/docs/guide/rust/polymorphism.md
+++ b/docs/guide/rust/polymorphism.md
@@ -64,7 +64,7 @@ struct Zoo {
star_animal: Box<dyn Animal>,
}
-let mut fory = Fory::default().compatible(true);
+let mut fory = Fory::builder().compatible(true).build();
fory.register::<Dog>(100);
fory.register::<Cat>(101);
fory.register::<Zoo>(102);
@@ -153,7 +153,7 @@ struct AnimalShelter {
registry: HashMap<String, Arc<dyn Animal>>,
}
-let mut fory = Fory::default().compatible(true);
+let mut fory = Fory::builder().compatible(true).build();
fory.register::<Dog>(100);
fory.register::<Cat>(101);
fory.register::<AnimalShelter>(102);
diff --git a/docs/guide/rust/schema-evolution.md
b/docs/guide/rust/schema-evolution.md
index f58db6ad0..6b51ba1ac 100644
--- a/docs/guide/rust/schema-evolution.md
+++ b/docs/guide/rust/schema-evolution.md
@@ -47,10 +47,10 @@ struct PersonV2 {
metadata: HashMap<String, String>,
}
-let mut fory1 = Fory::default().compatible(true);
+let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<PersonV1>(1);
-let mut fory2 = Fory::default().compatible(true);
+let mut fory2 = Fory::builder().compatible(true).build();
fory2.register::<PersonV2>(1);
let person_v1 = PersonV1 {
@@ -155,7 +155,7 @@ enum NewEvent {
KeyPress(String), // New variant
}
-let mut fory = Fory::default().compatible(true);
+let mut fory = Fory::builder().compatible(true).build();
// Serialize with old schema
let old_bytes = fory.serialize(&OldEvent::Click { x: 100, y: 200 })?;
diff --git a/docs/guide/rust/troubleshooting.md
b/docs/guide/rust/troubleshooting.md
index f67f5071a..6d99c551b 100644
--- a/docs/guide/rust/troubleshooting.md
+++ b/docs/guide/rust/troubleshooting.md
@@ -51,7 +51,7 @@ Confirm that:
- Ensure field types match across versions
```rust
-let fory = Fory::default().compatible(true);
+let fory = Fory::builder().compatible(true).build();
```
## Debugging Techniques
diff --git a/docs/guide/rust/type-registration.md
b/docs/guide/rust/type-registration.md
index 0c209ce55..d44d0094a 100644
--- a/docs/guide/rust/type-registration.md
+++ b/docs/guide/rust/type-registration.md
@@ -52,9 +52,9 @@ let decoded: User = fory.deserialize(&bytes)?;
For cross-language compatibility, register with namespace and type name:
```rust
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
// Register with namespace-based naming
fory.register_by_namespace::<MyStruct>("com.example", "MyStruct")?;
diff --git a/docs/guide/xlang/field-reference-tracking.md
b/docs/guide/xlang/field-reference-tracking.md
index f6076c13c..d7729c240 100644
--- a/docs/guide/xlang/field-reference-tracking.md
+++ b/docs/guide/xlang/field-reference-tracking.md
@@ -64,9 +64,9 @@ auto fory =
fory::Fory::builder().xlang(true).track_ref(true).build();
### Rust
```rust
-let fory = Fory::default()
+let fory = Fory::builder()
.xlang(true)
- .track_ref(true);
+ .track_ref(true).build();
```
## Wire Format
@@ -158,7 +158,7 @@ FORY_STRUCT(Document, title, author, data, tag_owner);
```
To disable reference tracking for C++ entirely, set
-`Fory::builder().track_ref(false)` on the serializer.
+`Fory::builder().track_ref(false).build()` on the serializer.
#### Rust: Field Attributes
diff --git a/docs/guide/xlang/getting-started.md
b/docs/guide/xlang/getting-started.md
index ae0d2a17c..9cc41d5fe 100644
--- a/docs/guide/xlang/getting-started.md
+++ b/docs/guide/xlang/getting-started.md
@@ -113,7 +113,7 @@ fory := forygo.NewFory(forygo.WithXlang(true),
forygo.WithTrackRef(true))
```rust
use fory::Fory;
-let fory = Fory::default().xlang(true);
+let fory = Fory::builder().xlang(true).build();
```
### JavaScript
@@ -173,7 +173,7 @@ struct Person {
age: i32,
}
-let mut fory = Fory::default().xlang(true);
+let mut fory = Fory::builder().xlang(true).build();
fory
.register_by_namespace::<Person>("example", "Person")
.expect("register Person");
diff --git a/docs/guide/xlang/serialization.md
b/docs/guide/xlang/serialization.md
index c9b270ebd..a646db6e5 100644
--- a/docs/guide/xlang/serialization.md
+++ b/docs/guide/xlang/serialization.md
@@ -133,7 +133,7 @@ console.log(result);
use fory::Fory;
fn run() {
- let fory = Fory::default().xlang(true);
+ let fory = Fory::builder().xlang(true).build();
let bin = fory.serialize(&"hello".to_string()).expect("serialize success");
let obj: String = fory.deserialize(&bin).expect("deserialize success");
assert_eq!("hello".to_string(), obj);
@@ -399,7 +399,7 @@ fn complex_struct() {
c6: 4.0,
};
- let mut fory = Fory::default().xlang(true);
+ let mut fory = Fory::builder().xlang(true).build();
fory
.register_by_namespace::<Animal>("example", "foo2")
.expect("register Animal");
diff --git a/integration_tests/idl_tests/rust/tests/idl_roundtrip.rs
b/integration_tests/idl_tests/rust/tests/idl_roundtrip.rs
index c286f80d2..7f2c3869b 100644
--- a/integration_tests/idl_tests/rust/tests/idl_roundtrip.rs
+++ b/integration_tests/idl_tests/rust/tests/idl_roundtrip.rs
@@ -507,9 +507,9 @@ fn test_address_book_roundtrip_schema_consistent() {
#[test]
fn test_evolving_roundtrip() {
- let mut fory_v1 = Fory::default().xlang(true).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(true).compatible(true).build();
evolving1::register_types(&mut fory_v1).expect("register evolving1 types");
- let mut fory_v2 = Fory::default().xlang(true).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(true).compatible(true).build();
evolving2::register_types(&mut fory_v2).expect("register evolving2 types");
let msg_v1 = evolving1::EvolvingMessage {
@@ -557,7 +557,10 @@ fn test_evolving_roundtrip() {
}
fn run_address_book_roundtrip(compatible: bool) {
- let mut fory = Fory::default().xlang(true).compatible(compatible);
+ let mut fory = Fory::builder()
+ .xlang(true)
+ .compatible(compatible)
+ .build();
complex_pb::register_types(&mut fory).expect("register complex pb types");
addressbook::register_types(&mut fory).expect("register types");
auto_id::register_types(&mut fory).expect("register auto_id types");
@@ -764,10 +767,11 @@ fn run_address_book_roundtrip(compatible: bool) {
let result: Result<AnyHolder, _> = fory.deserialize(&bytes);
assert!(result.is_err());
- let mut ref_fory = Fory::default()
+ let mut ref_fory = Fory::builder()
.xlang(true)
.compatible(compatible)
- .track_ref(true);
+ .track_ref(true)
+ .build();
tree::register_types(&mut ref_fory).expect("register tree types");
graph::register_types(&mut ref_fory).expect("register graph types");
diff --git a/rust/README.md b/rust/README.md
index 40ac4549e..34648dc92 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -280,7 +280,7 @@ struct Zoo {
star_animal: Box<dyn Animal>,
}
-let mut fory = Fory::default().compatible(true);
+let mut fory = Fory::builder().compatible(true).build();
fory.register::<Dog>(100);
fory.register::<Cat>(101);
fory.register::<Zoo>(102);
@@ -339,10 +339,10 @@ struct PersonV2 {
metadata: HashMap<String, String>,
}
-let mut fory1 = Fory::default().compatible(true);
+let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<PersonV1>(1);
-let mut fory2 = Fory::default().compatible(true);
+let mut fory2 = Fory::builder().compatible(true).build();
fory2.register::<PersonV2>(1);
let person_v1 = PersonV1 {
@@ -601,9 +601,9 @@ Apache Fory™ supports seamless data exchange across
multiple languages:
use fory::Fory;
// Enable cross-language mode
-let mut fory = Fory::default()
+let mut fory = Fory::builder()
.compatible(true)
- .xlang(true);
+ .xlang(true).build();
// Register types with consistent IDs across languages
fory.register::<MyStruct>(100);
diff --git a/rust/fory-core/src/fory.rs b/rust/fory-core/src/fory.rs
index 0aeded559..7ad755546 100644
--- a/rust/fory-core/src/fory.rs
+++ b/rust/fory-core/src/fory.rs
@@ -43,72 +43,27 @@ thread_local! {
UnsafeCell::new(ContextCache::new());
}
-/// The main Fory serialization framework instance.
-///
-/// `Fory` provides high-performance cross-language serialization and
deserialization
-/// capabilities with support for multiple modes, reference tracking, and
trait object serialization.
-///
-/// # Features
-///
-/// - **Cross-language serialization**: Serialize data in Rust and deserialize
in other languages
-/// - **Multiple modes**: Schema-consistent and compatible serialization modes
-/// - **Reference tracking**: Handles shared and circular references
-/// - **Trait object serialization**: Supports serializing polymorphic trait
objects
-/// - **Dynamic depth limiting**: Configurable limit for nested dynamic object
serialization
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```rust, ignore
-/// use fory::Fory;
-/// use fory::ForyObject;
-///
-/// #[derive(ForyObject)]
-/// struct User {
-/// name: String,
-/// age: u32,
-/// }
-///
-/// let fory = Fory::default();
-/// let user = User { name: "Alice".to_string(), age: 30 };
-/// let bytes = fory.serialize(&user);
-/// let deserialized: User = fory.deserialize(&bytes).unwrap();
-/// ```
+/// Builder for configuring a [`Fory`] runtime before first use.
///
-/// Custom configuration:
+/// `ForyBuilder` owns the configuration phase. Call [`build`](Self::build) to
create the
+/// runtime, then use [`Fory`] for registration and serialization operations.
///
/// ```rust
/// use fory_core::Fory;
///
-/// let fory = Fory::default()
+/// let fory = Fory::builder()
/// .compatible(true)
/// .compress_string(true)
-/// .max_dyn_depth(10);
+/// .max_dyn_depth(10)
+/// .build();
/// ```
-pub struct Fory {
- /// Unique identifier for this Fory instance, used as key in thread-local
context maps.
- id: u64,
- /// Configuration for serialization behavior.
+#[derive(Default)]
+pub struct ForyBuilder {
config: Config,
- type_resolver: TypeResolver,
- /// Lazy-initialized final type resolver (thread-safe, one-time
initialization).
- final_type_resolver: OnceLock<Result<TypeResolver, Error>>,
}
-impl Default for Fory {
- fn default() -> Self {
- Fory {
- id: FORY_ID_COUNTER.fetch_add(1, Ordering::Relaxed),
- config: Config::default(),
- type_resolver: TypeResolver::default(),
- final_type_resolver: OnceLock::new(),
- }
- }
-}
-
-impl Fory {
- /// Sets the serialization compatible mode for this Fory instance.
+impl ForyBuilder {
+ /// Sets the serialization compatible mode for this Fory builder.
///
/// # Arguments
///
@@ -133,13 +88,12 @@ impl Fory {
/// ```rust
/// use fory_core::Fory;
///
- /// let fory = Fory::default().compatible(true);
+ /// let fory = Fory::builder().compatible(true).build();
/// ```
pub fn compatible(mut self, compatible: bool) -> Self {
// Setting share_meta individually is not supported currently
self.config.share_meta = compatible;
self.config.compatible = compatible;
- self.type_resolver.set_compatible(compatible);
if compatible {
self.config.check_struct_version = false;
}
@@ -168,18 +122,17 @@ impl Fory {
/// use fory_core::Fory;
///
/// // For cross-language use (default)
- /// let fory = Fory::default().xlang(true);
+ /// let fory = Fory::builder().xlang(true).build();
///
/// // For Rust-only optimization, this mode is faster and more compact
since it avoids
/// // cross-language metadata and type system costs.
- /// let fory = Fory::default().xlang(false);
+ /// let fory = Fory::builder().xlang(false).build();
/// ```
pub fn xlang(mut self, xlang: bool) -> Self {
self.config.xlang = xlang;
if !self.config.check_struct_version {
self.config.check_struct_version = !self.config.compatible;
}
- self.type_resolver.set_xlang(xlang);
self
}
@@ -209,7 +162,7 @@ impl Fory {
/// ```rust
/// use fory_core::Fory;
///
- /// let fory = Fory::default().compress_string(true);
+ /// let fory = Fory::builder().compress_string(true).build();
/// ```
pub fn compress_string(mut self, compress_string: bool) -> Self {
self.config.compress_string = compress_string;
@@ -243,9 +196,10 @@ impl Fory {
/// ```rust
/// use fory_core::Fory;
///
- /// let fory = Fory::default()
+ /// let fory = Fory::builder()
/// .compatible(false)
- /// .check_struct_version(true);
+ /// .check_struct_version(true)
+ /// .build();
/// ```
pub fn check_struct_version(mut self, check_struct_version: bool) -> Self {
if self.config.compatible && check_struct_version {
@@ -277,7 +231,7 @@ impl Fory {
/// ```rust
/// use fory_core::Fory;
///
- /// let fory = Fory::default().track_ref(true);
+ /// let fory = Fory::builder().track_ref(true).build();
/// ```
pub fn track_ref(mut self, track_ref: bool) -> Self {
self.config.track_ref = track_ref;
@@ -311,10 +265,10 @@ impl Fory {
/// use fory_core::Fory;
///
/// // Allow deeper nesting for complex object graphs
- /// let fory = Fory::default().max_dyn_depth(10);
+ /// let fory = Fory::builder().max_dyn_depth(10).build();
///
/// // Restrict nesting for safer deserialization
- /// let fory = Fory::default().max_dyn_depth(3);
+ /// let fory = Fory::builder().max_dyn_depth(3).build();
/// ```
pub fn max_dyn_depth(mut self, max_dyn_depth: u32) -> Self {
self.config.max_dyn_depth = max_dyn_depth;
@@ -343,7 +297,7 @@ impl Fory {
/// use fory_core::Fory;
///
/// // Limit binary payloads to 1 MB
- /// let fory = Fory::default().max_binary_size(1024 * 1024);
+ /// let fory = Fory::builder().max_binary_size(1024 * 1024).build();
/// ```
pub fn max_binary_size(mut self, max_binary_size: u32) -> Self {
self.config.max_binary_size = max_binary_size;
@@ -373,13 +327,97 @@ impl Fory {
/// use fory_core::Fory;
///
/// // Limit collections to 10000 elements
- /// let fory = Fory::default().max_collection_size(10000);
+ /// let fory = Fory::builder().max_collection_size(10000).build();
/// ```
pub fn max_collection_size(mut self, max_collection_size: u32) -> Self {
self.config.max_collection_size = max_collection_size;
self
}
+ /// Builds a [`Fory`] runtime with the current builder configuration.
+ pub fn build(self) -> Fory {
+ Fory::from_config(self.config)
+ }
+}
+
+/// The main Fory serialization framework instance.
+///
+/// `Fory` provides high-performance cross-language serialization and
deserialization
+/// capabilities with support for multiple modes, reference tracking, and
trait object serialization.
+///
+/// # Features
+///
+/// - **Cross-language serialization**: Serialize data in Rust and deserialize
in other languages
+/// - **Multiple modes**: Schema-consistent and compatible serialization modes
+/// - **Reference tracking**: Handles shared and circular references
+/// - **Trait object serialization**: Supports serializing polymorphic trait
objects
+/// - **Dynamic depth limiting**: Configurable limit for nested dynamic object
serialization
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```rust, ignore
+/// use fory::Fory;
+/// use fory::ForyObject;
+///
+/// #[derive(ForyObject)]
+/// struct User {
+/// name: String,
+/// age: u32,
+/// }
+///
+/// let fory = Fory::default();
+/// let user = User { name: "Alice".to_string(), age: 30 };
+/// let bytes = fory.serialize(&user);
+/// let deserialized: User = fory.deserialize(&bytes).unwrap();
+/// ```
+///
+/// Custom configuration:
+///
+/// ```rust
+/// use fory_core::Fory;
+///
+/// let fory = Fory::builder()
+/// .compatible(true)
+/// .compress_string(true)
+/// .max_dyn_depth(10)
+/// .build();
+/// ```
+pub struct Fory {
+ /// Unique identifier for this Fory instance, used as key in thread-local
context maps.
+ id: u64,
+ /// Configuration for serialization behavior.
+ config: Config,
+ type_resolver: TypeResolver,
+ /// Lazy-initialized final type resolver (thread-safe, one-time
initialization).
+ final_type_resolver: OnceLock<Result<TypeResolver, Error>>,
+}
+
+impl Default for Fory {
+ fn default() -> Self {
+ Self::builder().build()
+ }
+}
+
+impl Fory {
+ /// Creates a builder for configuring a [`Fory`] runtime.
+ pub fn builder() -> ForyBuilder {
+ ForyBuilder::default()
+ }
+
+ fn from_config(config: Config) -> Self {
+ let mut type_resolver = TypeResolver::default();
+ type_resolver.set_compatible(config.compatible);
+ type_resolver.set_xlang(config.xlang);
+ Self {
+ id: FORY_ID_COUNTER.fetch_add(1, Ordering::Relaxed),
+ config,
+ type_resolver,
+ final_type_resolver: OnceLock::new(),
+ }
+ }
+
/// Returns whether cross-language serialization is enabled.
pub fn is_xlang(&self) -> bool {
self.config.xlang
diff --git a/rust/fory-core/src/lib.rs b/rust/fory-core/src/lib.rs
index 976a760af..b9be2e764 100644
--- a/rust/fory-core/src/lib.rs
+++ b/rust/fory-core/src/lib.rs
@@ -99,7 +99,7 @@
//! }
//!
//! # fn main() {
-//! let mut fory = Fory::default().compatible(true);
+//! let mut fory = Fory::builder().compatible(true).build();
//! fory.register::<Dog>(100);
//! fory.register::<Cat>(101);
//! fory.register::<Zoo>(102);
@@ -147,7 +147,7 @@
//! use std::collections::HashMap;
//!
//! // Create a Fory instance
-//! let mut fory = Fory::default().compatible(true);
+//! let mut fory = Fory::builder().compatible(true).build();
//!
//! // Serialize String
//! let text = String::from("Hello, Fory!");
@@ -195,7 +195,7 @@ pub use paste;
pub use crate::buffer::{Reader, Writer};
pub use crate::config::Config;
pub use crate::error::Error;
-pub use crate::fory::Fory;
+pub use crate::fory::{Fory, ForyBuilder};
pub use crate::resolver::context::{ReadContext, WriteContext};
pub use crate::resolver::type_resolver::{TypeInfo, TypeResolver};
pub use crate::serializer::weak::{ArcWeak, RcWeak};
diff --git a/rust/fory-core/src/serializer/trait_object.rs
b/rust/fory-core/src/serializer/trait_object.rs
index f5b9ddf5b..6367e533c 100644
--- a/rust/fory-core/src/serializer/trait_object.rs
+++ b/rust/fory-core/src/serializer/trait_object.rs
@@ -90,7 +90,7 @@ macro_rules! downcast_and_serialize {
/// register_trait_type!(Animal, Dog, Cat);
///
/// # fn main() {
-/// let mut fory = Fory::default().compatible(true);
+/// let mut fory = Fory::builder().compatible(true).build();
/// fory.register::<Dog>(100);
/// fory.register::<Cat>(101);
///
diff --git a/rust/fory-core/src/serializer/weak.rs
b/rust/fory-core/src/serializer/weak.rs
index 0bdd96aca..26b3e6f2f 100644
--- a/rust/fory-core/src/serializer/weak.rs
+++ b/rust/fory-core/src/serializer/weak.rs
@@ -338,7 +338,7 @@ impl<T: Serializer + ForyDefault + 'static> Serializer for
RcWeak<T> {
// Weak pointers require track_ref to be enabled on the Fory instance
if !context.is_track_ref() {
return Err(Error::invalid_ref(
- "RcWeak requires track_ref to be enabled. Use
Fory::default().track_ref(true)",
+ "RcWeak requires track_ref to be enabled. Use
Fory::builder().track_ref(true).build()",
));
}
// Weak MUST use ref tracking - otherwise read value will be lost
@@ -511,7 +511,7 @@ impl<T: Serializer + ForyDefault + Send + Sync + 'static>
Serializer for ArcWeak
// Weak pointers require track_ref to be enabled on the Fory instance
if !context.is_track_ref() {
return Err(Error::invalid_ref(
- "ArcWeak requires track_ref to be enabled. Use
Fory::default().track_ref(true)",
+ "ArcWeak requires track_ref to be enabled. Use
Fory::builder().track_ref(true).build()",
));
}
// Weak MUST use ref tracking - otherwise read value will be lost
diff --git a/rust/fory/src/lib.rs b/rust/fory/src/lib.rs
index f38cc7a37..d8199eb22 100644
--- a/rust/fory/src/lib.rs
+++ b/rust/fory/src/lib.rs
@@ -251,7 +251,7 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory = Fory::default().track_ref(true);
+//! let mut fory = Fory::builder().track_ref(true).build();
//! fory.register::<Node>(2000);
//!
//! let parent = Rc::new(RefCell::new(Node {
@@ -293,7 +293,7 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory = Fory::default().track_ref(true);
+//! let mut fory = Fory::builder().track_ref(true).build();
//! fory.register::<Node>(6000);
//!
//! let parent = Arc::new(Mutex::new(Node {
@@ -374,7 +374,7 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory = Fory::default().compatible(true);
+//! let mut fory = Fory::builder().compatible(true).build();
//! fory.register::<Dog>(100);
//! fory.register::<Cat>(101);
//! fory.register::<Zoo>(102);
@@ -501,7 +501,7 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory = Fory::default().compatible(true);
+//! let mut fory = Fory::builder().compatible(true).build();
//! fory.register::<Dog>(100);
//! fory.register::<Cat>(101);
//! fory.register::<AnimalShelter>(102);
@@ -555,7 +555,7 @@
//! register_trait_type!(Animal, Dog);
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory = Fory::default().compatible(true);
+//! let mut fory = Fory::builder().compatible(true).build();
//! fory.register::<Dog>(100);
//!
//! // For Rc<dyn Trait>
@@ -630,10 +630,10 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory1 = Fory::default().compatible(true);
+//! let mut fory1 = Fory::builder().compatible(true).build();
//! fory1.register::<PersonV1>(1);
//!
-//! let mut fory2 = Fory::default().compatible(true);
+//! let mut fory2 = Fory::builder().compatible(true).build();
//! fory2.register::<PersonV2>(1);
//!
//! let person_v1 = PersonV1 {
@@ -727,10 +727,10 @@
//! }
//!
//! # fn main() -> Result<(), Error> {
-//! let mut fory_old = Fory::default().compatible(true);
+//! let mut fory_old = Fory::builder().compatible(true).build();
//! fory_old.register::<OldEvent>(5)?;
//!
-//! let mut fory_new = Fory::default().compatible(true);
+//! let mut fory_new = Fory::builder().compatible(true).build();
//! fory_new.register::<NewEvent>(5)?;
//!
//! // Serialize with old schema (2 fields)
@@ -1034,7 +1034,7 @@
//! ```rust
//! use fory::Fory;
//!
-//! let fory = Fory::default().compatible(true);
+//! let fory = Fory::builder().compatible(true).build();
//! ```
//!
//! ## Cross-Language Serialization
@@ -1051,9 +1051,9 @@
//! use fory::Fory;
//! use fory::ForyObject;
//!
-//! let mut fory = Fory::default()
+//! let mut fory = Fory::builder()
//! .compatible(true)
-//! .xlang(true);
+//! .xlang(true).build();
//!
//! #[derive(ForyObject)]
//! struct MyStruct {
@@ -1201,8 +1201,8 @@
//! - **[GitHub Repository](https://github.com/apache/fory)** - Source code
and issue tracking
pub use fory_core::{
- error::Error, fory::Fory, register_trait_type, row::from_row, row::to_row,
types::TypeId,
- ArcWeak, ForyDefault, RcWeak, ReadContext, Reader, Serializer,
TypeResolver, WriteContext,
- Writer,
+ error::Error, fory::Fory, fory::ForyBuilder, register_trait_type,
row::from_row, row::to_row,
+ types::TypeId, ArcWeak, ForyDefault, RcWeak, ReadContext, Reader,
Serializer, TypeResolver,
+ WriteContext, Writer,
};
pub use fory_derive::{ForyObject, ForyRow};
diff --git a/rust/tests/tests/compatible/test_basic_type.rs
b/rust/tests/tests/compatible/test_basic_type.rs
index 4f08fee64..d1e124411 100644
--- a/rust/tests/tests/compatible/test_basic_type.rs
+++ b/rust/tests/tests/compatible/test_basic_type.rs
@@ -415,7 +415,7 @@ fn deserialize_nullable(fory: &Fory, bins: Vec<u8>,
auto_conv: bool) {
// non-null <-> non-null
#[test]
fn basic() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// serialize
let bins = serialize_non_null(&fory);
// deserialize
@@ -425,7 +425,7 @@ fn basic() {
// nullable <-> nullable
#[test]
fn basic_nullable() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// serialize
let bins = serialize_nullable(&fory);
// deserialize
@@ -435,7 +435,7 @@ fn basic_nullable() {
// non-null -> nullable -> non-null
#[test]
fn auto_conv() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// serialize_non-null
let bins = serialize_non_null(&fory);
deserialize_nullable(&fory, bins, true);
diff --git a/rust/tests/tests/compatible/test_container.rs
b/rust/tests/tests/compatible/test_container.rs
index 2076574ef..f5d9189c3 100644
--- a/rust/tests/tests/compatible/test_container.rs
+++ b/rust/tests/tests/compatible/test_container.rs
@@ -219,7 +219,7 @@ fn complex_container2() -> Vec<HashMap<Vec<Item>,
Vec<Item>>> {
#[test]
fn container_outer_auto_conv() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// serialize_outer_non-null
let bytes = fory.serialize(&basic_list()).unwrap();
assert_eq!(
@@ -285,9 +285,9 @@ fn container_outer_auto_conv() {
#[test]
fn collection_inner() {
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<Item>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
// serialize
@@ -348,9 +348,9 @@ fn collection_inner() {
#[test]
fn collection_inner_auto_conv() {
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<Item>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
// serialize_non_null
@@ -416,9 +416,9 @@ fn collection_inner_auto_conv() {
#[test]
fn map_inner() {
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<Item>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
// serialize
@@ -453,9 +453,9 @@ fn map_inner() {
#[test]
fn map_inner_auto_conv() {
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<Item>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
// serialize_non_null
@@ -493,9 +493,9 @@ fn map_inner_auto_conv() {
#[test]
fn complex() {
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<Item>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register_by_name::<Item>("item").unwrap();
for fory in [fory1, fory2] {
let mut bins = vec![
diff --git a/rust/tests/tests/compatible/test_struct.rs
b/rust/tests/tests/compatible/test_struct.rs
index 50533e51c..98ea7552a 100644
--- a/rust/tests/tests/compatible/test_struct.rs
+++ b/rust/tests/tests/compatible/test_struct.rs
@@ -45,8 +45,8 @@ fn simple() {
f7: i16,
last: i8,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Animal1>(999).unwrap();
fory2.register::<Animal2>(999).unwrap();
let animal: Animal1 = Animal1 {
@@ -84,8 +84,8 @@ fn skip_option() {
f2: i8,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
let item1 = Item1 {
@@ -123,8 +123,8 @@ fn nonexistent_struct() {
f3: i64,
last: String,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(899).unwrap();
fory1.register::<Person1>(999).unwrap();
fory2.register::<Item2>(799).unwrap();
@@ -155,7 +155,7 @@ fn option() {
f5: Vec<Option<Vec<Option<String>>>>,
last: i64,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Animal>(999).unwrap();
let animal: Animal = Animal {
f1: Some(String::from("f1")),
@@ -199,8 +199,8 @@ fn nullable() {
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -253,8 +253,8 @@ fn nullable_container() {
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -305,8 +305,8 @@ fn inner_nullable() {
f3: HashMap<i8, i8>,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -352,8 +352,8 @@ fn nullable_struct() {
f3: Item,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item>(199).unwrap();
fory1.register::<Person1>(200).unwrap();
fory2.register::<Item>(199).unwrap();
@@ -429,11 +429,11 @@ fn enum_without_payload() {
last: i8,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register::<Color1>(101).unwrap();
fory1.register::<Color2>(102).unwrap();
fory1.register::<Person1>(103).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register::<Color1>(101).unwrap();
fory2.register::<Color2>(102).unwrap();
fory2.register::<Person2>(103).unwrap();
@@ -495,10 +495,10 @@ fn named_enum() {
f6: Option<Color>,
last: i8,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register_by_name::<Color>("a").unwrap();
fory1.register::<Item1>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register_by_name::<Color>("a").unwrap();
fory2.register::<Item2>(101).unwrap();
let item1 = Item1 {
@@ -551,9 +551,9 @@ fn boxed() {
f6: Option<i32>,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register::<Item1>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register::<Item2>(101).unwrap();
let f1 = 1;
@@ -667,9 +667,9 @@ fn test_struct_with_generic() {
}
}
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
let mut fory2 = Fory::default(); // Without compatible it works fine.
- let mut fory3 = Fory::default().xlang(true); // Works fine with xlang
enabled
+ let mut fory3 = Fory::builder().xlang(true).build(); // Works fine with
xlang enabled
fn inner_test(fory: &mut Fory) -> Result<(), Error> {
fory.register::<MyStruct>(1)?;
diff --git a/rust/tests/tests/compatible/test_struct_enum.rs
b/rust/tests/tests/compatible/test_struct_enum.rs
index 0952b6833..63c92c3d0 100644
--- a/rust/tests/tests/compatible/test_struct_enum.rs
+++ b/rust/tests/tests/compatible/test_struct_enum.rs
@@ -44,8 +44,8 @@ fn simple() {
f7: i16,
last: i8,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Animal1>(999).unwrap();
fory2.register::<Animal2>(999).unwrap();
let animal: Animal1 = Animal1 {
@@ -81,7 +81,7 @@ fn simple_write_continuous() {
last: i8,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Animal1>(999).unwrap();
let animal: Animal1 = Animal1 {
f1: HashMap::from([(1, vec![2])]),
@@ -128,8 +128,8 @@ fn skip_option() {
f2: i8,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
let item1 = Item1 {
@@ -167,8 +167,8 @@ fn nonexistent_struct() {
f3: i64,
last: String,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(899).unwrap();
fory1.register::<Person1>(999).unwrap();
fory2.register::<Item2>(799).unwrap();
@@ -199,7 +199,7 @@ fn option() {
f5: Vec<Option<Vec<Option<String>>>>,
last: i64,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Animal>(999).unwrap();
let animal: Animal = Animal {
f1: Some(String::from("f1")),
@@ -243,8 +243,8 @@ fn nullable() {
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -297,8 +297,8 @@ fn nullable_container() {
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -349,8 +349,8 @@ fn inner_nullable() {
f3: HashMap<i8, i8>,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item1>(999).unwrap();
fory2.register::<Item2>(999).unwrap();
@@ -396,8 +396,8 @@ fn nullable_struct() {
f3: Item,
last: i64,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Item>(199).unwrap();
fory1.register::<Person1>(200).unwrap();
fory2.register::<Item>(199).unwrap();
@@ -473,11 +473,11 @@ fn enum_without_payload() {
last: i8,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register::<Color1>(101).unwrap();
fory1.register::<Color2>(102).unwrap();
fory1.register::<Person1>(103).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register::<Color1>(101).unwrap();
fory2.register::<Color2>(102).unwrap();
fory2.register::<Person2>(103).unwrap();
@@ -539,10 +539,10 @@ fn named_enum() {
f6: Option<Color>,
last: i8,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register_by_name::<Color>("a").unwrap();
fory1.register::<Item1>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register_by_name::<Color>("a").unwrap();
fory2.register::<Item2>(101).unwrap();
let item1 = Item1 {
@@ -595,9 +595,9 @@ fn boxed() {
f6: Option<i32>,
}
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register::<Item1>(101).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register::<Item2>(101).unwrap();
let f1 = 1;
diff --git a/rust/tests/tests/test_array.rs b/rust/tests/tests/test_array.rs
index 84e0201fe..784afcecd 100644
--- a/rust/tests/tests/test_array.rs
+++ b/rust/tests/tests/test_array.rs
@@ -255,7 +255,7 @@ register_trait_type!(Shape, Circle, Rectangle);
#[test]
fn test_array_box_trait_objects() {
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Circle>(9001).unwrap();
fory.register::<Rectangle>(9002).unwrap();
@@ -333,7 +333,7 @@ fn test_struct_with_vec_of_arrays() {
#[test]
fn test_array_rc_trait_objects() {
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Circle>(9001).unwrap();
fory.register::<Rectangle>(9002).unwrap();
diff --git a/rust/tests/tests/test_collection.rs
b/rust/tests/tests/test_collection.rs
index 0d6264793..d3f0684fc 100644
--- a/rust/tests/tests/test_collection.rs
+++ b/rust/tests/tests/test_collection.rs
@@ -131,7 +131,7 @@ fn test_hashset_max_collection_size_guardrail() {
]);
let serialized = fory.serialize(&original).unwrap();
- let limited_fory = Fory::default().max_collection_size(2);
+ let limited_fory = Fory::builder().max_collection_size(2).build();
let err = limited_fory
.deserialize::<HashSet<String>>(&serialized)
.expect_err("expected collection size guardrail to reject the
payload");
diff --git a/rust/tests/tests/test_cross_language.rs
b/rust/tests/tests/test_cross_language.rs
index 8a7b48288..712d6309c 100644
--- a/rust/tests/tests/test_cross_language.rs
+++ b/rust/tests/tests/test_cross_language.rs
@@ -243,15 +243,17 @@ fn test_string_serializer() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
let mut reader = Reader::new(bytes.as_slice());
- let fory = Fory::default()
+ let fory = Fory::builder()
.compatible(true)
.xlang(true)
- .compress_string(false);
+ .compress_string(false)
+ .build();
let mut reader_compress = Reader::new(bytes.as_slice());
- let fory_compress = Fory::default()
+ let fory_compress = Fory::builder()
.compatible(true)
.xlang(true)
- .compress_string(true);
+ .compress_string(true)
+ .build();
let test_strings: Vec<String> = vec![
// Latin1
"ab".to_string(),
@@ -273,7 +275,7 @@ fn test_string_serializer() {
.unwrap()
);
}
- let fory = Fory::default().compatible(true).xlang(true);
+ let fory = Fory::builder().compatible(true).xlang(true).build();
let mut buf = Vec::new();
for s in &test_strings {
fory.serialize_to(&mut buf, s).unwrap();
@@ -305,7 +307,7 @@ fn test_cross_language_serializer() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
let mut reader = Reader::new(bytes.as_slice());
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Color>(101).unwrap();
assert_de!(fory, reader, bool, true);
assert_de!(fory, reader, bool, false);
@@ -372,7 +374,7 @@ fn test_cross_language_serializer() {
fn test_simple_struct() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Color>(101).unwrap();
fory.register::<Item>(102).unwrap();
fory.register::<SimpleStruct>(103).unwrap();
@@ -403,7 +405,7 @@ fn test_simple_struct() {
fn test_named_simple_struct() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register_by_namespace::<Color>("demo", "color")
.unwrap();
fory.register_by_namespace::<Item>("demo", "item").unwrap();
@@ -436,7 +438,7 @@ fn test_named_simple_struct() {
fn test_struct_evolving_override() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register_by_namespace::<EvolvingOverrideStruct>("test",
"evolving_yes")
.unwrap();
fory.register_by_namespace::<FixedOverrideStruct>("test", "evolving_off")
@@ -470,7 +472,7 @@ fn test_list() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Item>(102).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -512,7 +514,7 @@ fn test_map() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Item>(102).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -585,7 +587,7 @@ fn test_integer() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Item2>(101).unwrap();
let mut reader = Reader::new(bytes.as_slice());
let f1 = 1;
@@ -692,10 +694,10 @@ fn _test_skip_custom(fory1: &Fory, fory2: &Fory) {
#[test]
#[ignore]
fn test_skip_id_custom() {
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1.register_serializer::<MyExt>(103).unwrap();
fory1.register::<Empty>(104).unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register::<Color>(101).unwrap();
fory2.register::<MyStruct>(102).unwrap();
fory2.register_serializer::<MyExt>(103).unwrap();
@@ -706,12 +708,12 @@ fn test_skip_id_custom() {
#[test]
#[ignore]
fn test_skip_name_custom() {
- let mut fory1 = Fory::default().compatible(true).xlang(true);
+ let mut fory1 = Fory::builder().compatible(true).xlang(true).build();
fory1
.register_serializer_by_name::<MyExt>("my_ext")
.unwrap();
fory1.register_by_name::<Empty>("my_wrapper").unwrap();
- let mut fory2 = Fory::default().compatible(true).xlang(true);
+ let mut fory2 = Fory::builder().compatible(true).xlang(true).build();
fory2.register_by_name::<Color>("color").unwrap();
fory2.register_by_name::<MyStruct>("my_struct").unwrap();
fory2
@@ -724,7 +726,7 @@ fn test_skip_name_custom() {
#[test]
#[ignore]
fn test_consistent_named() {
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register_by_name::<Color>("color").unwrap();
fory.register_by_name::<MyStruct>("my_struct").unwrap();
fory.register_serializer_by_name::<MyExt>("my_ext").unwrap();
@@ -827,10 +829,11 @@ struct TwoEnumFieldStruct {
fn test_struct_version_check() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default()
+ let mut fory = Fory::builder()
.compatible(false)
.xlang(true)
- .check_struct_version(true);
+ .check_struct_version(true)
+ .build();
fory.register::<VersionCheckStruct>(201).unwrap();
let local_obj = VersionCheckStruct {
@@ -852,7 +855,7 @@ fn test_item() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Item>(102).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -887,7 +890,7 @@ fn test_color() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Color>(101).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -914,7 +917,7 @@ fn test_struct_with_list() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<StructWithList>(201).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -946,7 +949,7 @@ fn test_struct_with_map() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<StructWithMap>(202).unwrap();
let mut reader = Reader::new(bytes.as_slice());
@@ -1009,7 +1012,7 @@ fn test_polymorphic_list() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Dog>(302).unwrap();
fory.register::<Cat>(303).unwrap();
fory.register::<AnimalListHolder>(304).unwrap();
@@ -1060,7 +1063,7 @@ fn test_polymorphic_map() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<Dog>(302).unwrap();
fory.register::<Cat>(303).unwrap();
fory.register::<AnimalMapHolder>(305).unwrap();
@@ -1123,7 +1126,7 @@ fn test_one_string_field_schema() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register::<OneStringFieldStruct>(200).unwrap();
let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap();
@@ -1139,7 +1142,7 @@ fn test_one_string_field_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<OneStringFieldStruct>(200).unwrap();
let value: OneStringFieldStruct = fory.deserialize(&bytes).unwrap();
@@ -1155,7 +1158,7 @@ fn test_two_string_field_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TwoStringFieldStruct>(201).unwrap();
let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap();
@@ -1173,7 +1176,7 @@ fn test_schema_evolution_compatible() {
let bytes = fs::read(&data_file_path).unwrap();
// Read TwoStringFieldStruct data as EmptyStructEvolution
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<EmptyStructEvolution>(200).unwrap();
let value: EmptyStructEvolution = fory.deserialize(&bytes).unwrap();
@@ -1190,7 +1193,7 @@ fn test_schema_evolution_compatible_reverse() {
let bytes = fs::read(&data_file_path).unwrap();
// Read OneStringFieldStruct data as TwoStringFieldStruct (missing f2)
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TwoStringFieldStruct>(200).unwrap();
let value: TwoStringFieldStruct = fory.deserialize(&bytes).unwrap();
@@ -1214,7 +1217,7 @@ fn test_one_enum_field_schema() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register::<TestEnum>(210).unwrap();
fory.register::<OneEnumFieldStruct>(211).unwrap();
@@ -1231,7 +1234,7 @@ fn test_one_enum_field_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TestEnum>(210).unwrap();
fory.register::<OneEnumFieldStruct>(211).unwrap();
@@ -1248,7 +1251,7 @@ fn test_two_enum_field_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TestEnum>(210).unwrap();
fory.register::<TwoEnumFieldStruct>(212).unwrap();
@@ -1267,7 +1270,7 @@ fn test_enum_schema_evolution_compatible() {
let bytes = fs::read(&data_file_path).unwrap();
// Read TwoEnumFieldStruct data as EmptyStructEvolution
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TestEnum>(210).unwrap();
fory.register::<EmptyStructEvolution>(211).unwrap();
@@ -1285,7 +1288,7 @@ fn test_enum_schema_evolution_compatible_reverse() {
let bytes = fs::read(&data_file_path).unwrap();
// Read OneEnumFieldStruct data as TwoEnumFieldStruct (missing f2)
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<TestEnum>(210).unwrap();
fory.register::<TwoEnumFieldStruct>(211).unwrap();
@@ -1420,7 +1423,7 @@ fn test_nullable_field_schema_consistent_not_null() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register::<NullableComprehensiveSchemaConsistent>(401)
.unwrap();
@@ -1470,7 +1473,7 @@ fn test_nullable_field_schema_consistent_null() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register::<NullableComprehensiveSchemaConsistent>(401)
.unwrap();
@@ -1523,7 +1526,7 @@ fn test_nullable_field_compatible_not_null() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<NullableComprehensiveCompatible>(402)
.unwrap();
@@ -1583,7 +1586,7 @@ fn test_nullable_field_compatible_null() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<NullableComprehensiveCompatible>(402)
.unwrap();
@@ -1667,7 +1670,7 @@ fn test_union_xlang() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
// Register both the enum and the struct that contains it
fory.register::<StringOrLong>(300).unwrap();
fory.register::<StructWithUnion2>(301).unwrap();
@@ -1761,10 +1764,11 @@ fn test_ref_schema_consistent() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default()
+ let mut fory = Fory::builder()
.compatible(false)
.xlang(true)
- .track_ref(true);
+ .track_ref(true)
+ .build();
fory.register::<RefInnerSchemaConsistent>(501).unwrap();
fory.register::<RefOuterSchemaConsistent>(502).unwrap();
@@ -1808,7 +1812,11 @@ fn test_ref_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory =
Fory::default().compatible(true).xlang(true).track_ref(true);
+ let mut fory = Fory::builder()
+ .compatible(true)
+ .xlang(true)
+ .track_ref(true)
+ .build();
fory.register::<RefInnerCompatible>(503).unwrap();
fory.register::<RefOuterCompatible>(504).unwrap();
@@ -1848,10 +1856,11 @@ fn test_collection_element_ref_override() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default()
+ let mut fory = Fory::builder()
.compatible(false)
.xlang(true)
- .track_ref(true);
+ .track_ref(true)
+ .build();
fory.register::<RefOverrideElement>(701).unwrap();
fory.register::<RefOverrideContainer>(702).unwrap();
@@ -1902,10 +1911,11 @@ fn test_circular_ref_schema_consistent() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default()
+ let mut fory = Fory::builder()
.compatible(false)
.xlang(true)
- .track_ref(true);
+ .track_ref(true)
+ .build();
fory.register::<CircularRefStruct>(601).unwrap();
// Deserialize as Rc<CircularRefStruct> since the whole struct needs ref
tracking
@@ -1946,7 +1956,11 @@ fn test_circular_ref_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory =
Fory::default().compatible(true).xlang(true).track_ref(true);
+ let mut fory = Fory::builder()
+ .compatible(true)
+ .xlang(true)
+ .track_ref(true)
+ .build();
fory.register::<CircularRefStruct>(602).unwrap();
// Deserialize as Rc<CircularRefStruct> since the whole struct needs ref
tracking
@@ -2061,7 +2075,7 @@ fn test_unsigned_schema_consistent() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(false).xlang(true);
+ let mut fory = Fory::builder().compatible(false).xlang(true).build();
fory.register::<UnsignedSchemaConsistent>(501).unwrap();
let local_obj = UnsignedSchemaConsistent {
@@ -2098,7 +2112,7 @@ fn test_unsigned_schema_compatible() {
let data_file_path = get_data_file();
let bytes = fs::read(&data_file_path).unwrap();
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
fory.register::<UnsignedSchemaCompatible>(502).unwrap();
let local_obj = UnsignedSchemaCompatible {
diff --git a/rust/tests/tests/test_debug.rs b/rust/tests/tests/test_debug.rs
index 7c0e86369..a83e3a9f8 100644
--- a/rust/tests/tests/test_debug.rs
+++ b/rust/tests/tests/test_debug.rs
@@ -150,7 +150,7 @@ fn debug_hooks_trigger_for_struct() {
event_log().lock().unwrap().clear();
- let mut fory_compat = Fory::default().compatible(true);
+ let mut fory_compat = Fory::builder().compatible(true).build();
fory_compat.register::<DebugSample>(4001).unwrap();
let compat_bytes = fory_compat.serialize(&sample).unwrap();
let _: DebugSample =
fory_compat.deserialize(compat_bytes.as_slice()).unwrap();
diff --git a/rust/tests/tests/test_enum.rs b/rust/tests/tests/test_enum.rs
index 6e5722bb8..a355ed11d 100644
--- a/rust/tests/tests/test_enum.rs
+++ b/rust/tests/tests/test_enum.rs
@@ -34,7 +34,7 @@ fn basic() {
Map(HashMap<String, Token>),
}
- let mut fory = Fory::default().xlang(false);
+ let mut fory = Fory::builder().xlang(false).build();
fory.register::<Token>(1000).unwrap();
let mut map = HashMap::new();
@@ -75,10 +75,10 @@ fn named_enum() {
Assign { value: i32, target: String },
}
- let mut fory1 = Fory::default().xlang(false);
+ let mut fory1 = Fory::builder().xlang(false).build();
fory1.register::<Token1>(1000).unwrap();
- let mut fory2 = Fory::default().xlang(false);
+ let mut fory2 = Fory::builder().xlang(false).build();
fory2.register::<Token2>(1000).unwrap();
let token = Token1::Assign {
@@ -132,7 +132,7 @@ fn struct_with_enum_field() {
Color::fory_static_type_id()
);
- let mut fory = Fory::default().xlang(true).compatible(false);
+ let mut fory = Fory::builder().xlang(true).compatible(false).build();
fory.register::<Color>(100).unwrap();
fory.register::<StructWithEnum>(101).unwrap();
@@ -176,7 +176,7 @@ fn union_compatible_enum_xlang_format() {
}
// Test xlang mode serialization
- let mut fory = Fory::default().xlang(true).compatible(false);
+ let mut fory = Fory::builder().xlang(true).compatible(false).build();
fory.register::<StringOrLong>(300).unwrap();
fory.register::<StructWithUnion>(301).unwrap();
@@ -224,7 +224,7 @@ fn struct_with_enum_field_explicit_nullable() {
"Status should have ENUM TypeId"
);
- let mut fory = Fory::default().xlang(true).compatible(false);
+ let mut fory = Fory::builder().xlang(true).compatible(false).build();
fory.register::<Status>(200).unwrap();
fory.register::<StructWithExplicitNullable>(201).unwrap();
diff --git a/rust/tests/tests/test_enum_compatible.rs
b/rust/tests/tests/test_enum_compatible.rs
index 8d5c0f383..a6623e89a 100644
--- a/rust/tests/tests/test_enum_compatible.rs
+++ b/rust/tests/tests/test_enum_compatible.rs
@@ -40,10 +40,10 @@ fn test_unnamed_enum_variant_compatible() {
}
// Test 1: Serialize v1 (2 fields), deserialize as v2 (3 fields)
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<EventV1>(2000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<EventV2>(2000).unwrap();
let event_v1 = EventV1::Message(42, "hello".to_string());
@@ -80,7 +80,7 @@ fn test_unnamed_enum_variant_compatible() {
NewVariant(bool), // This variant doesn't exist in EventV1
}
- let mut fory_v3 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build();
fory_v3.register::<EventV3>(2000).unwrap();
let event_v3 = EventV3::NewVariant(true);
@@ -117,10 +117,10 @@ fn test_named_enum_variant_compatible() {
},
}
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<CommandV1>(3000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<CommandV2>(3000).unwrap();
// Test 1: Serialize v1, deserialize as v2 (new field gets default value)
@@ -198,13 +198,13 @@ fn test_named_enum_field_evolution() {
},
}
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<ConfigV1>(4000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<ConfigV2>(4000).unwrap();
- let mut fory_v3 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build();
fory_v3.register::<ConfigV3>(4000).unwrap();
// Test V1 -> V2: New fields get default values
@@ -319,13 +319,13 @@ fn test_named_enum_variant_add_remove() {
},
}
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<TaskV1>(5000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<TaskV2>(5000).unwrap();
- let mut fory_v3 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build();
fory_v3.register::<TaskV3>(5000).unwrap();
// Test V2 (new variant Completed) -> V1: Unknown variant falls back to
default
@@ -458,13 +458,13 @@ fn test_enum_variant_type_change() {
Finished, // Unnamed -> Unit
}
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<StatusV1>(6000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<StatusV2>(6000).unwrap();
- let mut fory_v3 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build();
fory_v3.register::<StatusV3>(6000).unwrap();
// Test V1 Unit -> V2 Named: Type mismatch, uses default value
@@ -593,15 +593,15 @@ fn test_struct_with_enum_field_evolution() {
sender: Option<String>, // New optional field
}
- let mut fory_v1 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v1 = Fory::builder().xlang(false).compatible(true).build();
fory_v1.register::<StateV1>(7001).unwrap();
fory_v1.register::<MessageV1>(7000).unwrap();
- let mut fory_v2 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v2 = Fory::builder().xlang(false).compatible(true).build();
fory_v2.register::<StateV2>(7001).unwrap();
fory_v2.register::<MessageV2>(7000).unwrap();
- let mut fory_v3 = Fory::default().xlang(false).compatible(true);
+ let mut fory_v3 = Fory::builder().xlang(false).compatible(true).build();
fory_v3.register::<StateV3>(7001).unwrap();
fory_v3.register::<MessageV3>(7000).unwrap();
diff --git a/rust/tests/tests/test_ext.rs b/rust/tests/tests/test_ext.rs
index 2cf0cc7b4..294769569 100644
--- a/rust/tests/tests/test_ext.rs
+++ b/rust/tests/tests/test_ext.rs
@@ -82,7 +82,7 @@ fn test_use() {
self
}
}
- let mut fory = Fory::default().compatible(true).xlang(true);
+ let mut fory = Fory::builder().compatible(true).xlang(true).build();
let item = Item { f1: 1, f2: 2 };
fory.register_serializer::<Item>(100).unwrap();
let bytes = fory.serialize(&item).unwrap();
diff --git a/rust/tests/tests/test_field_meta.rs
b/rust/tests/tests/test_field_meta.rs
index 034640459..b0f0b3920 100644
--- a/rust/tests/tests/test_field_meta.rs
+++ b/rust/tests/tests/test_field_meta.rs
@@ -326,10 +326,10 @@ mod compatible_v2 {
#[test]
fn test_compatible_mode_v1_to_v2() {
// Serialize with V1, deserialize with V2 (forward compatibility)
- let mut fory_v1 = Fory::default().compatible(true);
+ let mut fory_v1 = Fory::builder().compatible(true).build();
fory_v1.register::<compatible_v1::UserV1>(100).unwrap();
- let mut fory_v2 = Fory::default().compatible(true);
+ let mut fory_v2 = Fory::builder().compatible(true).build();
fory_v2.register::<compatible_v2::UserV2>(100).unwrap();
let user_v1 = compatible_v1::UserV1 {
@@ -351,10 +351,10 @@ fn test_compatible_mode_v1_to_v2() {
#[test]
fn test_compatible_mode_v2_to_v1() {
// Serialize with V2, deserialize with V1 (backward compatibility)
- let mut fory_v1 = Fory::default().compatible(true);
+ let mut fory_v1 = Fory::builder().compatible(true).build();
fory_v1.register::<compatible_v1::UserV1>(100).unwrap();
- let mut fory_v2 = Fory::default().compatible(true);
+ let mut fory_v2 = Fory::builder().compatible(true).build();
fory_v2.register::<compatible_v2::UserV2>(100).unwrap();
let user_v2 = compatible_v2::UserV2 {
@@ -407,12 +407,12 @@ mod compatible_reorder_v2 {
#[test]
fn test_compatible_mode_field_reorder() {
// Test that field IDs allow fields to be reordered between versions
- let mut fory_v1 = Fory::default().compatible(true);
+ let mut fory_v1 = Fory::builder().compatible(true).build();
fory_v1
.register::<compatible_reorder_v1::DataV1>(200)
.unwrap();
- let mut fory_v2 = Fory::default().compatible(true);
+ let mut fory_v2 = Fory::builder().compatible(true).build();
fory_v2
.register::<compatible_reorder_v2::DataV2>(200)
.unwrap();
@@ -466,12 +466,12 @@ mod compatible_remove_field_v2 {
#[test]
fn test_compatible_mode_field_removed() {
// Test that removed fields are handled in compatible mode
- let mut fory_v1 = Fory::default().compatible(true);
+ let mut fory_v1 = Fory::builder().compatible(true).build();
fory_v1
.register::<compatible_remove_field_v1::ConfigV1>(300)
.unwrap();
- let mut fory_v2 = Fory::default().compatible(true);
+ let mut fory_v2 = Fory::builder().compatible(true).build();
fory_v2
.register::<compatible_remove_field_v2::ConfigV2>(300)
.unwrap();
@@ -525,7 +525,7 @@ fn test_skip_with_field_id() {
#[test]
fn test_compatible_mode_roundtrip() {
// Test full roundtrip with compatible mode and field IDs
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<compatible_v2::UserV2>(400).unwrap();
let original = compatible_v2::UserV2 {
@@ -582,12 +582,12 @@ fn test_field_id_payload_compatible_mode() {
// Test that structs with field IDs produce smaller payloads in compatible
mode.
// Field IDs are encoded as compact 1-2 byte integers instead of full
field names,
// following the xlang serialization spec (TAG_ID encoding with 2-bit
marker 0b11).
- let mut fory_compact = Fory::default().compatible(true);
+ let mut fory_compact = Fory::builder().compatible(true).build();
fory_compact
.register::<payload_with_field_ids::CompactUser>(500)
.unwrap();
- let mut fory_verbose = Fory::default().compatible(true);
+ let mut fory_verbose = Fory::builder().compatible(true).build();
fory_verbose
.register::<payload_without_field_ids::VerboseUser>(501)
.unwrap();
diff --git a/rust/tests/tests/test_fory.rs b/rust/tests/tests/test_fory.rs
index 332428f9e..ebd2bb29f 100644
--- a/rust/tests/tests/test_fory.rs
+++ b/rust/tests/tests/test_fory.rs
@@ -338,9 +338,10 @@ fn test_size_guardrail_configuration_accessors() {
assert_eq!(default_fory.get_max_binary_size(), 64 * 1024 * 1024);
assert_eq!(default_fory.get_max_collection_size(), 1024 * 1024);
- let configured_fory = Fory::default()
+ let configured_fory = Fory::builder()
.max_binary_size(4096)
- .max_collection_size(128);
+ .max_collection_size(128)
+ .build();
assert_eq!(configured_fory.get_max_binary_size(), 4096);
assert_eq!(configured_fory.get_max_collection_size(), 128);
}
@@ -351,7 +352,7 @@ fn test_max_binary_size_does_not_limit_string_reads() {
let original = "this string should not be treated as binary".repeat(4);
let serialized = fory.serialize(&original).unwrap();
- let limited_fory = Fory::default().max_binary_size(4);
+ let limited_fory = Fory::builder().max_binary_size(4).build();
let deserialized: String = limited_fory.deserialize(&serialized).unwrap();
assert_eq!(deserialized, original);
diff --git a/rust/tests/tests/test_list.rs b/rust/tests/tests/test_list.rs
index 0c8f8f5d2..b119697e4 100644
--- a/rust/tests/tests/test_list.rs
+++ b/rust/tests/tests/test_list.rs
@@ -197,7 +197,7 @@ fn test_vec_max_collection_size_guardrail() {
let original = vec!["alpha".to_string(), "beta".to_string(),
"gamma".to_string()];
let serialized = fory.serialize(&original).unwrap();
- let limited_fory = Fory::default().max_collection_size(2);
+ let limited_fory = Fory::builder().max_collection_size(2).build();
let err = limited_fory
.deserialize::<Vec<String>>(&serialized)
.expect_err("expected vec deserialization to fail on
max_collection_size");
diff --git a/rust/tests/tests/test_map.rs b/rust/tests/tests/test_map.rs
index 832dca516..b7562a1d0 100644
--- a/rust/tests/tests/test_map.rs
+++ b/rust/tests/tests/test_map.rs
@@ -78,7 +78,7 @@ fn test_hashmap_max_collection_size_guardrail() {
]);
let serialized = fory.serialize(&map).unwrap();
- let limited_fory = Fory::default().max_collection_size(2);
+ let limited_fory = Fory::builder().max_collection_size(2).build();
let err = limited_fory
.deserialize::<HashMap<String, i32>>(&serialized)
.expect_err("expected hashmap deserialization to fail on
max_collection_size");
@@ -103,7 +103,7 @@ fn test_btreemap_max_collection_size_guardrail() {
]);
let serialized = fory.serialize(&map).unwrap();
- let limited_fory = Fory::default().max_collection_size(2);
+ let limited_fory = Fory::builder().max_collection_size(2).build();
let err = limited_fory
.deserialize::<BTreeMap<String, i32>>(&serialized)
.expect_err("expected btreemap deserialization to fail on
max_collection_size");
diff --git a/rust/tests/tests/test_max_dyn_depth.rs
b/rust/tests/tests/test_max_dyn_depth.rs
index 521a11303..03f7e3d82 100644
--- a/rust/tests/tests/test_max_dyn_depth.rs
+++ b/rust/tests/tests/test_max_dyn_depth.rs
@@ -32,7 +32,10 @@ fn test_max_dyn_depth_exceeded_box_dyn_any() {
return;
}
for compatible in [false, true] {
- let mut fory = Fory::default().max_dyn_depth(2).compatible(compatible);
+ let mut fory = Fory::builder()
+ .max_dyn_depth(2)
+ .compatible(compatible)
+ .build();
fory.register::<Container>(100).unwrap();
let level3 = Container {
@@ -66,7 +69,7 @@ fn test_max_dyn_depth_within_limit_box_dyn_any() {
if fory_core::error::should_panic_on_error() {
return;
}
- let mut fory = Fory::default().max_dyn_depth(3);
+ let mut fory = Fory::builder().max_dyn_depth(3).build();
fory.register::<Container>(100).unwrap();
let level3 = Container {
diff --git a/rust/tests/tests/test_one_struct.rs
b/rust/tests/tests/test_one_struct.rs
index 070d3af04..bc69903bf 100644
--- a/rust/tests/tests/test_one_struct.rs
+++ b/rust/tests/tests/test_one_struct.rs
@@ -46,8 +46,8 @@ fn test_simple() {
f7: i16,
last: i8,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Animal1>(999).unwrap();
fory2.register::<Animal2>(999).unwrap();
let animal: Animal1 = Animal1 {
diff --git a/rust/tests/tests/test_rc_arc_trait_object.rs
b/rust/tests/tests/test_rc_arc_trait_object.rs
index 2bbed8a1a..1ebc7b035 100644
--- a/rust/tests/tests/test_rc_arc_trait_object.rs
+++ b/rust/tests/tests/test_rc_arc_trait_object.rs
@@ -25,7 +25,7 @@ use std::rc::Rc;
use std::sync::Arc;
fn fory_compatible() -> Fory {
- Fory::default().compatible(true)
+ Fory::builder().compatible(true).build()
}
trait Animal: Serializer + Send + Sync {
diff --git a/rust/tests/tests/test_simple_struct.rs
b/rust/tests/tests/test_simple_struct.rs
index 94b7542e0..b0cb285ff 100644
--- a/rust/tests/tests/test_simple_struct.rs
+++ b/rust/tests/tests/test_simple_struct.rs
@@ -68,8 +68,8 @@ fn test_compatible_field_type_change() {
value: Option<i32>,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<Data1>(100).unwrap();
fory2.register::<Data2>(100).unwrap();
@@ -92,10 +92,11 @@ fn test_struct_evolving_override() {
id: i32,
}
- let mut fory = Fory::default()
+ let mut fory = Fory::builder()
.xlang(true)
.compatible(true)
- .track_ref(false);
+ .track_ref(false)
+ .build();
fory.register::<Evolving>(100).unwrap();
fory.register::<Fixed>(101).unwrap();
@@ -129,8 +130,8 @@ fn test_compatible_to_empty_struct() {
#[derive(ForyObject, Debug)]
struct EmptyData {}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<DataWithField>(101).unwrap();
fory2.register::<EmptyData>(101).unwrap();
@@ -155,8 +156,8 @@ fn test_compatible_from_empty_struct() {
name: String,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<EmptyData>(102).unwrap();
fory2.register::<DataWithField>(102).unwrap();
@@ -178,8 +179,8 @@ fn test_compatible_vec_to_empty_struct() {
#[derive(ForyObject, Debug)]
struct EmptyData {}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<DataWithField>(101).unwrap();
fory2.register::<EmptyData>(101).unwrap();
@@ -203,8 +204,8 @@ fn test_compatible_map_to_empty_struct() {
#[derive(ForyObject, Debug)]
struct EmptyData {}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<DataWithField>(101).unwrap();
fory2.register::<EmptyData>(101).unwrap();
diff --git a/rust/tests/tests/test_skip_fields.rs
b/rust/tests/tests/test_skip_fields.rs
index 3f9cabd3e..5bb4b3699 100644
--- a/rust/tests/tests/test_skip_fields.rs
+++ b/rust/tests/tests/test_skip_fields.rs
@@ -357,7 +357,7 @@ fn test_trait_object_serialization() {
skipped_animal: Box<dyn Animal>,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<Dog>(100).unwrap();
fory.register::<Cat>(101).unwrap();
fory.register::<Zoo>(102).unwrap();
@@ -397,7 +397,7 @@ fn test_trait_object_serialization() {
normal_field: String,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<ComplexSkipExample>(106).unwrap();
let complex = ComplexSkipExample {
diff --git a/rust/tests/tests/test_trait_object.rs
b/rust/tests/tests/test_trait_object.rs
index 03979b27d..4113d35db 100644
--- a/rust/tests/tests/test_trait_object.rs
+++ b/rust/tests/tests/test_trait_object.rs
@@ -22,7 +22,7 @@ use fory_derive::ForyObject;
use std::collections::{HashMap, HashSet};
fn fory_compatible() -> Fory {
- Fory::default().compatible(true)
+ Fory::builder().compatible(true).build()
}
#[test]
diff --git a/rust/tests/tests/test_tuple.rs b/rust/tests/tests/test_tuple.rs
index a28ea35c0..864e3cf5f 100644
--- a/rust/tests/tests/test_tuple.rs
+++ b/rust/tests/tests/test_tuple.rs
@@ -230,7 +230,7 @@ fn test_tuple_type_id() {
// Test tuples in xlang mode
#[test]
fn test_tuple_xlang_mode() {
- let fory = Fory::default().xlang(true);
+ let fory = Fory::builder().xlang(true).build();
// Test homogeneous tuple
let homogeneous = (1i32, 2i32, 3i32);
@@ -268,7 +268,7 @@ fn run_struct_with_simple_tuple_fields(xlang: bool) {
triple: (bool, u32, i64),
}
- let mut fory = Fory::default().xlang(xlang);
+ let mut fory = Fory::builder().xlang(xlang).build();
fory.register::<SimpleTupleStruct>(1).unwrap();
let data = SimpleTupleStruct {
@@ -304,7 +304,7 @@ fn run_struct_with_complex_tuple_fields(xlang: bool) {
complex_nested: ComplexNestedTuple,
}
- let mut fory = Fory::default().xlang(xlang);
+ let mut fory = Fory::builder().xlang(xlang).build();
fory.register::<ComplexTupleStruct>(2).unwrap();
let data = ComplexTupleStruct {
diff --git a/rust/tests/tests/test_tuple_compatible.rs
b/rust/tests/tests/test_tuple_compatible.rs
index 43458cb29..6b61cd01d 100644
--- a/rust/tests/tests/test_tuple_compatible.rs
+++ b/rust/tests/tests/test_tuple_compatible.rs
@@ -34,7 +34,7 @@ const PI_F64: f64 = std::f64::consts::PI;
/// Test 1: Direct tuple size mismatch - bidirectional serialization
#[test]
fn test_tuple_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Test 1a: Long tuple serialized, short tuple deserialized
let long = (42i32, "hello".to_string(), PI_F64, true);
@@ -57,7 +57,7 @@ fn test_tuple_size_mismatch() {
/// Test 2: Tuples containing list/set/map elements
#[test]
fn test_tuple_with_collections_compatible() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Tuple with Vec
let tuple_vec = (vec![1, 2, 3], vec!["a".to_string(), "b".to_string()]);
let bin = fory.serialize(&tuple_vec).unwrap();
@@ -104,7 +104,7 @@ fn test_tuple_with_collections_compatible() {
/// Test 2b: Tuple with collections - length mismatch
#[test]
fn test_tuple_collections_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize tuple with 3 collections
let tuple_long = (vec![1, 2, 3], vec!["a".to_string()], vec![1.0, 2.0]);
@@ -129,7 +129,7 @@ fn test_tuple_collections_size_mismatch() {
/// Test 3: Nested tuples
#[test]
fn test_nested_tuples() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
let obj = ((42i32, "hello".to_string()), (PI_F64, true));
let bin = fory.serialize(&obj).unwrap();
@@ -140,7 +140,7 @@ fn test_nested_tuples() {
/// Test 3b: Nested tuple size mismatch
#[test]
fn test_nested_tuple_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Long to short
let long = ((42i32, "test".to_string(), PI_F64), (true, 100i32));
@@ -164,7 +164,7 @@ fn test_nested_tuple_size_mismatch() {
/// Test 3c: Deeply nested tuples with size mismatch
#[test]
fn test_deeply_nested_tuple_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize deeply nested tuple
let deep = (1i32, (2i32, (3i32, 4i32, 5i32)));
@@ -191,7 +191,7 @@ fn test_deeply_nested_tuple_size_mismatch() {
/// Test 4: Tuples with Option/Arc elements
#[test]
fn test_tuple_with_option_arc_compatible() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Tuple with Options
let tuple_opt = (Some(42i32), None::<String>, Some(PI_F64));
@@ -225,7 +225,7 @@ fn test_tuple_with_option_arc_compatible() {
/// Test 4b: Tuple with Option size mismatch
#[test]
fn test_tuple_option_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize longer tuple
let long = (
@@ -257,7 +257,7 @@ fn test_tuple_option_size_mismatch() {
/// Test 4c: Tuple with Arc size mismatch
#[test]
fn test_tuple_arc_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize longer tuple
let long = (Arc::new(1i32), Arc::new(2i32), Arc::new(3i32));
@@ -282,7 +282,7 @@ fn test_tuple_arc_size_mismatch() {
/// Test 5: Schema evolution from homogeneous to heterogeneous tuple
#[test]
fn test_tuple_homogeneous_to_heterogeneous() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize as homogeneous (all i32)
let homogeneous = (1i32, 2i32, 3i32);
@@ -306,7 +306,7 @@ fn test_tuple_homogeneous_to_heterogeneous() {
/// Test 6: Schema evolution with different element counts
#[test]
fn test_tuple_element_count_evolution() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Test growing from 2 to 5 elements
let small = (42i32, "hello".to_string());
@@ -343,7 +343,7 @@ fn test_tuple_element_count_evolution() {
/// Test 6b: Complex element count evolution
#[test]
fn test_tuple_element_count_evolution_complex() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// v1: simple 2-element tuple
let v1 = (42i32, "hello".to_string());
@@ -369,7 +369,7 @@ fn test_tuple_element_count_evolution_complex() {
/// Test 7: Edge case - empty tuple behavior
#[test]
fn test_empty_to_non_empty_tuple() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Simulate deserializing to tuple when data is missing
// This is tested implicitly through struct field defaults
@@ -382,7 +382,7 @@ fn test_empty_to_non_empty_tuple() {
/// Test 8: Very large tuple with size mismatch
#[test]
fn test_large_tuple_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Serialize a large tuple (10 elements)
let large = (1i32, 2i32, 3i32, 4i32, 5i32, 6i32, 7i32, 8i32, 9i32, 10i32);
@@ -414,7 +414,7 @@ fn test_large_tuple_size_mismatch() {
/// Test 9: Mixed complex types with size mismatch
#[test]
fn test_mixed_complex_types_size_mismatch() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Complex tuple with many different types
let complex = (
@@ -445,7 +445,7 @@ fn test_mixed_complex_types_size_mismatch() {
/// Test compatible mode with tuples
#[test]
fn test_tuple_xlang_compatible_mode() {
- let fory = Fory::default().compatible(true);
+ let fory = Fory::builder().compatible(true).build();
// Test basic tuple
let basic = (42i32, "hello".to_string(), vec![1, 2, 3]);
let bin = fory.serialize(&basic).unwrap();
@@ -501,10 +501,10 @@ fn run_struct_missing_tuple_field(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(1).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(1).unwrap();
// Serialize V1 and deserialize as V2
@@ -553,10 +553,10 @@ fn run_struct_added_tuple_field(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(2).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(2).unwrap();
// Serialize V1 and deserialize as V2 (new tuple fields should be default)
@@ -601,10 +601,10 @@ fn run_struct_tuple_element_increase(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(3).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(3).unwrap();
// Serialize V1 and deserialize as V2 (extra elements should be default)
@@ -648,10 +648,10 @@ fn run_struct_tuple_element_decrease(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(4).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(4).unwrap();
// Serialize V1 and deserialize as V2 (extra elements should be dropped)
@@ -698,10 +698,10 @@ fn run_struct_nested_tuple_evolution(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(5).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(5).unwrap();
// Serialize V1 and deserialize as V2
@@ -755,10 +755,10 @@ fn run_struct_multiple_tuple_fields_evolution(xlang:
bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<StructV1>(6).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<StructV2>(6).unwrap();
// Serialize V1 and deserialize as V2
@@ -925,10 +925,10 @@ fn run_struct_complex_evolution_scenario(xlang: bool) {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory1 = Fory::builder().xlang(xlang).compatible(true).build();
fory1.register::<DataRecordV1>(100).unwrap();
- let mut fory2 = Fory::default().xlang(xlang).compatible(true);
+ let mut fory2 = Fory::builder().xlang(xlang).compatible(true).build();
fory2.register::<DataRecordV2>(100).unwrap();
// Test V1 -> V2: Old schema to new schema
@@ -1035,10 +1035,10 @@ fn test_tuple_alias() {
}
// Use separate Fory instances with the same type ID
- let mut fory1 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
fory1.register::<DataRecordV1>(100).unwrap();
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory2 = Fory::builder().compatible(true).build();
fory2.register::<DataRecordV2>(100).unwrap();
// Test record1 serialized by fory1, deserialized by fory2
diff --git a/rust/tests/tests/test_tuple_struct.rs
b/rust/tests/tests/test_tuple_struct.rs
index 44bd60846..c7240dd2c 100644
--- a/rust/tests/tests/test_tuple_struct.rs
+++ b/rust/tests/tests/test_tuple_struct.rs
@@ -234,7 +234,7 @@ fn test_tuple_struct_with_tuple_field() {
#[test]
fn test_tuple_struct_xlang_mode() {
- let mut fory = Fory::default().xlang(true);
+ let mut fory = Fory::builder().xlang(true).build();
fory.register::<Point>(100).unwrap();
fory.register::<Wrapper>(102).unwrap();
fory.register::<Triple>(103).unwrap();
@@ -328,13 +328,13 @@ mod remote_v3 {
/// Test schema evolution: remote has fewer fields than local.
#[test]
fn test_tuple_struct_schema_evolution_add_field() {
- let mut fory_writer = Fory::default().compatible(true);
+ let mut fory_writer = Fory::builder().compatible(true).build();
fory_writer.register::<remote_v1::Point>(100).unwrap();
let remote_data = remote_v1::Point(1.0, 2.0);
let bytes = fory_writer.serialize(&remote_data).unwrap();
- let mut fory_reader = Fory::default().compatible(true);
+ let mut fory_reader = Fory::builder().compatible(true).build();
fory_reader.register::<local_v2::Point>(100).unwrap();
let local_data: local_v2::Point = fory_reader.deserialize(&bytes).unwrap();
@@ -347,13 +347,13 @@ fn test_tuple_struct_schema_evolution_add_field() {
/// Test schema evolution: remote has more fields than local.
#[test]
fn test_tuple_struct_schema_evolution_remove_field() {
- let mut fory_writer = Fory::default().compatible(true);
+ let mut fory_writer = Fory::builder().compatible(true).build();
fory_writer.register::<remote_v3::Point>(100).unwrap();
let remote_data = remote_v3::Point(1.0, 2.0, 3.0, 4.0);
let bytes = fory_writer.serialize(&remote_data).unwrap();
- let mut fory_reader = Fory::default().compatible(true);
+ let mut fory_reader = Fory::builder().compatible(true).build();
fory_reader.register::<remote_v1::Point>(100).unwrap();
let local_data: remote_v1::Point =
fory_reader.deserialize(&bytes).unwrap();
@@ -388,7 +388,7 @@ mod local_mixed_v3 {
/// Test that adding i64 (compress=true) doesn't break schema evolution
#[test]
fn test_tuple_struct_schema_evolution_add_i64() {
- let mut fory_writer = Fory::default().compatible(true);
+ let mut fory_writer = Fory::builder().compatible(true).build();
fory_writer
.register::<remote_mixed_v1::MixedPoint>(100)
.unwrap();
@@ -396,7 +396,7 @@ fn test_tuple_struct_schema_evolution_add_i64() {
let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0);
let bytes = fory_writer.serialize(&remote_data).unwrap();
- let mut fory_reader = Fory::default().compatible(true);
+ let mut fory_reader = Fory::builder().compatible(true).build();
fory_reader
.register::<local_mixed_v2::MixedPoint>(100)
.unwrap();
@@ -411,7 +411,7 @@ fn test_tuple_struct_schema_evolution_add_i64() {
/// Test that adding u8 (smaller size) doesn't break schema evolution
#[test]
fn test_tuple_struct_schema_evolution_add_u8() {
- let mut fory_writer = Fory::default().compatible(true);
+ let mut fory_writer = Fory::builder().compatible(true).build();
fory_writer
.register::<remote_mixed_v1::MixedPoint>(100)
.unwrap();
@@ -419,7 +419,7 @@ fn test_tuple_struct_schema_evolution_add_u8() {
let remote_data = remote_mixed_v1::MixedPoint(1.0, 2.0);
let bytes = fory_writer.serialize(&remote_data).unwrap();
- let mut fory_reader = Fory::default().compatible(true);
+ let mut fory_reader = Fory::builder().compatible(true).build();
fory_reader
.register::<local_mixed_v3::MixedPoint>(100)
.unwrap();
diff --git a/rust/tests/tests/test_unsigned.rs
b/rust/tests/tests/test_unsigned.rs
index c3a853ed6..d1f8373a9 100644
--- a/rust/tests/tests/test_unsigned.rs
+++ b/rust/tests/tests/test_unsigned.rs
@@ -45,7 +45,7 @@ fn test_unsigned_arrays() {
#[test]
fn test_unsigned_arrays_when_xlang() {
- let fory = Fory::default().xlang(true);
+ let fory = Fory::builder().xlang(true).build();
// u8, u16, u32, u64 arrays are now supported in xlang mode
assert!(fory.serialize(&vec![u8::MAX]).is_ok());
assert!(fory.serialize(&vec![u16::MAX]).is_ok());
@@ -58,7 +58,7 @@ fn test_unsigned_arrays_when_xlang() {
#[test]
fn test_binary_when_xlang() {
- let mut fory = Fory::default().xlang(true);
+ let mut fory = Fory::builder().xlang(true).build();
#[derive(ForyObject, Debug, PartialEq)]
struct UnsignedData {
binary: Vec<u8>,
@@ -78,7 +78,7 @@ fn test_binary_max_size_guardrail_for_vec_u8() {
let original = vec![1_u8, 2, 3, 4, 5];
let serialized = fory.serialize(&original).unwrap();
- let limited_fory = Fory::default().max_binary_size(4);
+ let limited_fory = Fory::builder().max_binary_size(4).build();
let err = limited_fory
.deserialize::<Vec<u8>>(&serialized)
.expect_err("expected binary size guardrail to reject the payload");
@@ -99,7 +99,7 @@ fn test_binary_max_size_guardrail_for_vec_u32() {
let original = vec![10_u32, 20, 30];
let serialized = fory.serialize(&original).unwrap();
- let limited_fory = Fory::default().max_binary_size(8);
+ let limited_fory = Fory::builder().max_binary_size(8).build();
let err = limited_fory
.deserialize::<Vec<u32>>(&serialized)
.expect_err("expected primitive array size guardrail to reject the
payload");
@@ -173,7 +173,7 @@ fn test_unsigned_struct_compatible() {
vec_u128: Vec<u128>,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<UnsignedData>(100).unwrap();
let data = UnsignedData {
@@ -211,8 +211,8 @@ fn test_unsigned_struct_compatible_add_field() {
c: u32,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<UnsignedDataV1>(101).unwrap();
fory2.register::<UnsignedDataV2>(101).unwrap();
@@ -239,8 +239,8 @@ fn test_unsigned_struct_compatible_remove_field() {
b: u16,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<UnsignedDataV1>(102).unwrap();
fory2.register::<UnsignedDataV2>(102).unwrap();
@@ -341,7 +341,7 @@ fn test_unsigned_with_option_compatible() {
opt_u128: Option<u128>,
}
- let mut fory = Fory::default().compatible(true);
+ let mut fory = Fory::builder().compatible(true).build();
fory.register::<OptionalUnsigned>(104).unwrap();
// Test with Some values
@@ -393,8 +393,8 @@ fn test_unsigned_mixed_fields_compatible() {
new_u128: u128,
}
- let mut fory1 = Fory::default().compatible(true);
- let mut fory2 = Fory::default().compatible(true);
+ let mut fory1 = Fory::builder().compatible(true).build();
+ let mut fory2 = Fory::builder().compatible(true).build();
fory1.register::<MixedDataV1>(105).unwrap();
fory2.register::<MixedDataV2>(105).unwrap();
diff --git a/rust/tests/tests/test_weak.rs b/rust/tests/tests/test_weak.rs
index ce3f53ea1..60174846f 100644
--- a/rust/tests/tests/test_weak.rs
+++ b/rust/tests/tests/test_weak.rs
@@ -25,7 +25,7 @@ use std::sync::Mutex;
#[test]
fn test_rc_weak_null_serialization() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let weak: RcWeak<i32> = RcWeak::new();
@@ -37,7 +37,7 @@ fn test_rc_weak_null_serialization() {
#[test]
fn test_arc_weak_null_serialization() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let weak: ArcWeak<i32> = ArcWeak::new();
@@ -49,7 +49,7 @@ fn test_arc_weak_null_serialization() {
#[test]
fn test_rc_weak_dead_pointer_serializes_as_null() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let weak = {
let rc = Rc::new(42i32);
@@ -69,7 +69,7 @@ fn test_rc_weak_dead_pointer_serializes_as_null() {
#[test]
fn test_arc_weak_dead_pointer_serializes_as_null() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let weak = {
let arc = Arc::new(String::from("test"));
@@ -89,7 +89,7 @@ fn test_arc_weak_dead_pointer_serializes_as_null() {
#[test]
fn test_rc_weak_in_vec_circular_reference() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let data1 = Rc::new(42i32);
let data2 = Rc::new(100i32);
@@ -107,7 +107,7 @@ fn test_rc_weak_in_vec_circular_reference() {
#[test]
fn test_arc_weak_in_vec_circular_reference() {
- let fory = Fory::default().track_ref(true);
+ let fory = Fory::builder().track_ref(true).build();
let data1 = Arc::new(String::from("hello"));
let data2 = Arc::new(String::from("world"));
@@ -133,7 +133,7 @@ fn test_rc_weak_field_in_struct() {
weak_ref: RcWeak<i32>,
}
- let mut fory = Fory::default().track_ref(true);
+ let mut fory = Fory::builder().track_ref(true).build();
fory.register::<SimpleNode>(1000).unwrap();
let data = Rc::new(42i32);
@@ -160,7 +160,7 @@ struct Node {
#[test]
fn test_node_circular_reference_with_parent_children() {
// Register the Node type with Fory
- let mut fory = Fory::default().track_ref(true);
+ let mut fory = Fory::builder().track_ref(true).build();
fory.register::<Node>(2000).unwrap();
// Create parent
@@ -218,7 +218,7 @@ fn test_arc_mutex_circular_reference() {
children: Vec<Arc<Mutex<Node>>>,
}
- let mut fory = Fory::default().track_ref(true);
+ let mut fory = Fory::builder().track_ref(true).build();
fory.register::<Node>(6000).unwrap();
let parent = Arc::new(Mutex::new(Node {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
